Kotlin Notes for Professionals (GoalKicker.com) (Z-Library)

📄 File Format: PDF

💾 File Size: 1.0 MB

📖 Read Online ⬇️ Download

Registered users can read the full content for free

Register as a Gaohf Library member to read the complete e-book online for free and enjoy a better reading experience.

📄 Page 1

Kotlin Notes for ProfessionalsKotlin® Notes for Professionals GoalKicker.com Free Programming Books Disclaimer This is an unocial free book created for educational purposes and is not aliated with ocial Kotlin® group(s) or company(s). All trademarks and registered trademarks are the property of their respective owners 80+ pages of professional hints and tricks

📄 Page 2

Contents About 1 ................................................................................................................................................................................... Chapter 1: Getting started with Kotlin 2 ............................................................................................................... Section 1.1: Hello World 2 ................................................................................................................................................. Section 1.2: Hello World using a Companion Object 2 .................................................................................................. Section 1.3: Hello World using an Object Declaration 3 ................................................................................................ Section 1.4: Main methods using varargs 4 .................................................................................................................... Section 1.5: Compile and Run Kotlin Code in Command Line 4 ................................................................................... Section 1.6: Reading input from Command Line 4 ........................................................................................................ Chapter 2: Basics of Kotlin 6 ....................................................................................................................................... Section 2.1: Basic examples 6 .......................................................................................................................................... Chapter 3: Strings 7 ......................................................................................................................................................... Section 3.1: String Equality 7 ............................................................................................................................................ Section 3.2: String Literals 7 ............................................................................................................................................ Section 3.3: Elements of String 8 ..................................................................................................................................... Section 3.4: String Templates 8 ....................................................................................................................................... Chapter 4: Arrays 9 ......................................................................................................................................................... Section 4.1: Generic Arrays 9 ........................................................................................................................................... Section 4.2: Arrays of Primitives 9 .................................................................................................................................. Section 4.3: Create an array 9 ........................................................................................................................................ Section 4.4: Create an array using a closure 9 ............................................................................................................. Section 4.5: Create an uninitialized array 9 ................................................................................................................... Section 4.6: Extensions 10 ................................................................................................................................................ Section 4.7: Iterate Array 10 ............................................................................................................................................ Chapter 5: Collections 11 .............................................................................................................................................. Section 5.1: Using list 11 ................................................................................................................................................... Section 5.2: Using map 11 ............................................................................................................................................... Section 5.3: Using set 11 .................................................................................................................................................. Chapter 6: Enum 12 .......................................................................................................................................................... Section 6.1: Initialization 12 .............................................................................................................................................. Section 6.2: Functions and Properties in enums 12 ...................................................................................................... Section 6.3: Simple enum 12 ............................................................................................................................................ Section 6.4: Mutability 12 ................................................................................................................................................. Chapter 7: Functions 14 ................................................................................................................................................. Section 7.1: Function References 14 ............................................................................................................................... Section 7.2: Basic Functions 15 ....................................................................................................................................... Section 7.3: Inline Functions 16 ....................................................................................................................................... Section 7.4: Lambda Functions 16 .................................................................................................................................. Section 7.5: Operator functions 16 ................................................................................................................................. Section 7.6: Functions Taking Other Functions 17 ........................................................................................................ Section 7.7: Shorthand Functions 17 .............................................................................................................................. Chapter 8: Vararg Parameters in Functions 18 ................................................................................................ Section 8.1: Basics: Using the vararg keyword 18 ......................................................................................................... Section 8.2: Spread Operator: Passing arrays into vararg functions 18 .................................................................... Chapter 9: Conditional Statements 19 ................................................................................................................... Section 9.1: When-statement argument matching 19 .................................................................................................. Section 9.2: When-statement as expression 19 ............................................................................................................

📄 Page 3

Section 9.3: Standard if-statement 19 ............................................................................................................................ Section 9.4: If-statement as an expression 19 ............................................................................................................... Section 9.5: When-statement instead of if-else-if chains 20 ....................................................................................... Section 9.6: When-statement with enums 20 ................................................................................................................ Chapter 10: Loops in Kotlin 22 .................................................................................................................................... Section 10.1: Looping over iterables 22 ........................................................................................................................... Section 10.2: Repeat an action x times 22 ...................................................................................................................... Section 10.3: Break and continue 22 ............................................................................................................................... Section 10.4: Iterating over a Map in kotlin 23 ............................................................................................................... Section 10.5: Recursion 23 ............................................................................................................................................... Section 10.6: While Loops 23 ........................................................................................................................................... Section 10.7: Functional constructs for iteration 23 ...................................................................................................... Chapter 11: Ranges 25 ..................................................................................................................................................... Section 11.1: Integral Type Ranges 25 ............................................................................................................................. Section 11.2: downTo() function 25 .................................................................................................................................. Section 11.3: step() function 25 ........................................................................................................................................ Section 11.4: until function 25 ........................................................................................................................................... Chapter 12: Regex 26 ....................................................................................................................................................... Section 12.1: Idioms for Regex Matching in When Expression 26 ................................................................................ Section 12.2: Introduction to regular expressions in Kotlin 27 ..................................................................................... Chapter 13: Basic Lambdas 30 .................................................................................................................................... Section 13.1: Lambda as parameter to filter function 30 .............................................................................................. Section 13.2: Lambda for benchmarking a function call 30 ......................................................................................... Section 13.3: Lambda passed as a variable 30 .............................................................................................................. Chapter 14: Null Safety 31 ........................................................................................................................................... Section 14.1: Smart casts 31 ............................................................................................................................................. Section 14.2: Assertion 31 ................................................................................................................................................. Section 14.3: Eliminate nulls from an Iterable and array 31 ......................................................................................... Section 14.4: Null Coalescing / Elvis Operator 31 .......................................................................................................... Section 14.5: Nullable and Non-Nullable types 32 ......................................................................................................... Section 14.6: Elvis Operator (?:) 32 .................................................................................................................................. Section 14.7: Safe call operator 32 .................................................................................................................................. Chapter 15: Class Delegation 34 ................................................................................................................................ Section 15.1: Delegate a method to another class 34 ................................................................................................... Chapter 16: Class Inheritance 35 ............................................................................................................................... Section 16.1: Basics: the 'open' keyword 35 .................................................................................................................... Section 16.2: Inheriting fields from a class 35 ................................................................................................................ Section 16.3: Inheriting methods from a class 36 .......................................................................................................... Section 16.4: Overriding properties and methods 36 .................................................................................................... Chapter 17: Visibility Modifiers 38 ............................................................................................................................. Section 17.1: Code Sample 38 ........................................................................................................................................... Chapter 18: Generics 39 ................................................................................................................................................. Section 18.1: Declaration-site variance 39 ...................................................................................................................... Section 18.2: Use-site variance 39 ................................................................................................................................... Chapter 19: Interfaces 41 .............................................................................................................................................. Section 19.1: Interface with default implementations 41 ............................................................................................... Section 19.2: Properties in Interfaces 42 ......................................................................................................................... Section 19.3: super keyword 42 ....................................................................................................................................... Section 19.4: Basic Interface 42 .......................................................................................................................................

📄 Page 4

Section 19.5: Conflicts when Implementing Multiple Interfaces with Default Implementations 43 .......................... Chapter 20: Singleton objects 44 .............................................................................................................................. Section 20.1: Use as replacement of static methods/fields of java 44 ....................................................................... Section 20.2: Use as a singleton 44 ................................................................................................................................ Chapter 21: coroutines 45 ............................................................................................................................................. Section 21.1: Simple coroutine which delay's 1 second but not blocks 45 ................................................................... Chapter 22: Annotations 46 ......................................................................................................................................... Section 22.1: Meta-annotations 46 .................................................................................................................................. Section 22.2: Declaring an annotation 46 ...................................................................................................................... Chapter 23: Type aliases 47 ......................................................................................................................................... Section 23.1: Function type 47 ......................................................................................................................................... Section 23.2: Generic type 47 .......................................................................................................................................... Chapter 24: Type-Safe Builders 48 ......................................................................................................................... Section 24.1: Type-safe tree structure builder 48 .......................................................................................................... Chapter 25: Delegated properties 49 ..................................................................................................................... Section 25.1: Observable properties 49 .......................................................................................................................... Section 25.2: Custom delegation 49 ............................................................................................................................... Section 25.3: Lazy initialization 49 .................................................................................................................................. Section 25.4: Map-backed properties 49 ....................................................................................................................... Section 25.5: Delegate Can be used as a layer to reduce boilerplate 49 .................................................................. Chapter 26: Reflection 51 ............................................................................................................................................. Section 26.1: Referencing a class 51 ............................................................................................................................... Section 26.2: Inter-operating with Java reflection 51 .................................................................................................. Section 26.3: Referencing a function 51 ......................................................................................................................... Section 26.4: Getting values of all properties of a class 51 ......................................................................................... Section 26.5: Setting values of all properties of a class 52 .......................................................................................... Chapter 27: Extension Methods 54 ........................................................................................................................... Section 27.1: Potential Pitfall: Extensions are Resolved Statically 54 .......................................................................... Section 27.2: Top-Level Extensions 54 ........................................................................................................................... Section 27.3: Lazy extension property workaround 54 ................................................................................................ Section 27.4: Sample extending Java 7+ Path class 55 ............................................................................................... Section 27.5: Sample extending long to render a human readable string 55 ........................................................... Section 27.6: Sample extending Java 8 Temporal classes to render an ISO formatted string 55 .......................... Section 27.7: Using extension functions to improve readability 55 ............................................................................. Section 27.8: Extension functions to Companion Objects (appearance of Static functions) 56 .............................. Section 27.9: Extensions for easier reference View from code 57 .............................................................................. Chapter 28: DSL Building 58 ........................................................................................................................................ Section 28.1: Infix approach to build DSL 58 .................................................................................................................. Section 28.2: Using operators with lambdas 58 ............................................................................................................ Section 28.3: Overriding invoke method to build DSL 58 ............................................................................................. Section 28.4: Using extensions with lambdas 58 ........................................................................................................... Chapter 29: Idioms 60 ..................................................................................................................................................... Section 29.1: Serializable and serialVersionUid in Kotlin 60 ......................................................................................... Section 29.2: Delegate to a class without providing it in the public constructor 60 .................................................. Section 29.3: Use let or also to simplify working with nullable objects 61 ................................................................. Section 29.4: Use apply to initialize objects or to achieve method chaining 61 ........................................................ Section 29.5: Fluent methods in Kotlin 61 ...................................................................................................................... Section 29.6: Filtering a list 62 ......................................................................................................................................... Section 29.7: Creating DTOs (POJOs/POCOs) 62 ........................................................................................................

📄 Page 5

Chapter 30: RecyclerView in Kotlin 63 ................................................................................................................... Section 30.1: Main class and Adapter 63 ........................................................................................................................ Chapter 31: logging in kotlin 65 .................................................................................................................................. Section 31.1: kotlin.logging 65 .......................................................................................................................................... Chapter 32: Exceptions 66 ............................................................................................................................................. Section 32.1: Catching exception with try-catch-finally 66 ........................................................................................... Chapter 33: JUnit 67 ........................................................................................................................................................ Section 33.1: Rules 67 ........................................................................................................................................................ Chapter 34: Kotlin Android Extensions 68 ............................................................................................................ Section 34.1: Using Views 68 ............................................................................................................................................ Section 34.2: Configuration 68 ........................................................................................................................................ Section 34.3: Painful listener for getting notice, when the view is completely drawn now is so simple and awesome with Kotlin's extension 69 ....................................................................................................................... Section 34.4: Product flavors 69 ..................................................................................................................................... Chapter 35: Kotlin for Java Developers 71 ......................................................................................................... Section 35.1: Declaring Variables 71 ............................................................................................................................... Section 35.2: Quick Facts 71 ............................................................................................................................................ Section 35.3: Equality & Identity 71 ................................................................................................................................. Section 35.4: IF, TRY and others are expressions, not statements 72 ......................................................................... Chapter 36: Java 8 Stream Equivalents 73 ......................................................................................................... Section 36.1: Accumulate names in a List 73 ................................................................................................................. Section 36.2: Collect example #5 - find people of legal age, output formatted string 73 ........................................ Section 36.3: Collect example #6 - group people by age, print age and names together 73 ................................. Section 36.4: Dierent Kinds of Streams #7 - lazily iterate Doubles, map to Int, map to String, print each 74 ................................................................................................................................................................................ Section 36.5: Counting items in a list after filter is applied 75 ..................................................................................... Section 36.6: Convert elements to strings and concatenate them, separated by commas 75 ............................... Section 36.7: Compute sum of salaries of employee 75 .............................................................................................. Section 36.8: Group employees by department 75 ...................................................................................................... Section 36.9: Compute sum of salaries by department 75 .......................................................................................... Section 36.10: Partition students into passing and failing 75 ....................................................................................... Section 36.11: Names of male members 76 ................................................................................................................... Section 36.12: Group names of members in roster by gender 76 ............................................................................... Section 36.13: Filter a list to another list 76 .................................................................................................................... Section 36.14: Finding shortest string a list 76 ............................................................................................................... Section 36.15: Dierent Kinds of Streams #2 - lazily using first item if exists 76 ....................................................... Section 36.16: Dierent Kinds of Streams #3 - iterate a range of Integers 77 .......................................................... Section 36.17: Dierent Kinds of Streams #4 - iterate an array, map the values, calculate the average 77 ................................................................................................................................................................................ Section 36.18: Dierent Kinds of Streams #5 - lazily iterate a list of strings, map the values, convert to Int, find max 77 ............................................................................................................................................................... Section 36.19: Dierent Kinds of Streams #6 - lazily iterate a stream of Ints, map the values, print results 77 ................................................................................................................................................................................ Section 36.20: How streams work - filter, upper case, then sort a list 78 ................................................................... Section 36.21: Dierent Kinds of Streams #1 - eager using first item if it exists 78 ................................................... Section 36.22: Collect example #7a - Map names, join together with delimiter 78 ................................................... Section 36.23: Collect example #7b - Collect with SummarizingInt 79 ....................................................................... Chapter 37: Kotlin Caveats 81 .................................................................................................................................... Section 37.1: Calling a toString() on a nullable type 81 ................................................................................................

📄 Page 6

Appendix A: Configuring Kotlin build 82 ................................................................................................................ Section A.1: Gradle configuration 82 ............................................................................................................................... Section A.2: Using Android Studio 83 ............................................................................................................................. Section A.3: Migrating from Gradle using Groovy script to Kotlin script 84 ............................................................... Credits 86 .............................................................................................................................................................................. You may also like 88 ........................................................................................................................................................

📄 Page 7

GoalKicker.com – Kotlin® Notes for Professionals 1 About Please feel free to share this PDF with anyone for free, latest version of this book can be downloaded from: https://goalkicker.com/KotlinBook This Kotlin® Notes for Professionals book is compiled from Stack Overflow Documentation, the content is written by the beautiful people at Stack Overflow. Text content is released under Creative Commons BY-SA, see credits at the end of this book whom contributed to the various chapters. Images may be copyright of their respective owners unless otherwise specified This is an unofficial free book created for educational purposes and is not affiliated with official Kotlin® group(s) or company(s) nor Stack Overflow. All trademarks and registered trademarks are the property of their respective company owners The information presented in this book is not guaranteed to be correct nor accurate, use at your own risk Please send feedback and corrections to web@petercv.com

📄 Page 8

GoalKicker.com – Kotlin® Notes for Professionals 2 Chapter 1: Getting started with Kotlin Version Release Date 1.0.0 2016-02-15 1.0.1 2016-03-16 1.0.2 2016-05-13 1.0.3 2016-06-30 1.0.4 2016-09-22 1.0.5 2016-11-08 1.0.6 2016-12-27 1.1.0 2017-03-01 1.1.1 2017-03-14 1.1.2 2017-04-25 1.1.3 2017-06-23 1.1.6 2017-11-13 1.2.2 2018-01-17 1.2.3 2018-03-01 1.2.4 2018-04-19 Section 1.1: Hello World All Kotlin programs start at the main function. Here is an example of a simple Kotlin "Hello World" program: package my.program fun main(args: Array<String>) { println("Hello, world!") } Place the above code into a file named Main.kt (this filename is entirely arbitrary) When targeting the JVM, the function will be compiled as a static method in a class with a name derived from the filename. In the above example, the main class to run would be my.program.MainKt. To change the name of the class that contains top-level functions for a particular file, place the following annotation at the top of the file above the package statement: @file:JvmName("MyApp") In this example, the main class to run would now be my.program.MyApp. See also: Package level functions including @JvmName annotation. Annotation use-site targets Section 1.2: Hello World using a Companion Object Similar to using an Object Declaration, you can define the main function of a Kotlin program using a Companion Object of a class.

📄 Page 9

GoalKicker.com – Kotlin® Notes for Professionals 3 package my.program class App { companion object { @JvmStatic fun main(args: Array<String>) { println("Hello World") } } } The class name that you will run is the name of your class, in this case is my.program.App. The advantage to this method over a top-level function is that the class name to run is more self-evident, and any other functions you add are scoped into the class App. This is similar to the Object Declaration example, other than you are in control of instantiating any classes to do further work. A slight variation that instantiates the class to do the actual "hello": class App { companion object { @JvmStatic fun main(args: Array<String>) { App().run() } } fun run() { println("Hello World") } } See also: Static Methods including the @JvmStatic annotation Section 1.3: Hello World using an Object Declaration You can alternatively use an Object Declaration that contains the main function for a Kotlin program. package my.program object App { @JvmStatic fun main(args: Array<String>) { println("Hello World") } } The class name that you will run is the name of your object, in this case is my.program.App. The advantage to this method over a top-level function is that the class name to run is more self-evident, and any other functions you add are scoped into the class App. You then also have a singleton instance of App to store state and do other work. See also: Static Methods including the @JvmStatic annotation

📄 Page 10

GoalKicker.com – Kotlin® Notes for Professionals 4 Section 1.4: Main methods using varargs All of these main method styles can also be used with varargs: package my.program fun main(vararg args: String) { println("Hello, world!") } Section 1.5: Compile and Run Kotlin Code in Command Line As java provide two different commands to compile and run Java code. Same as Kotlin also provide you different commands. javac to compile java files. java to run java files. Same as kotlinc to compile kotlin files kotlin to run kotlin files. Section 1.6: Reading input from Command Line The arguments passed from the console can be received in the Kotlin program and it can be used as an input. You can pass N (1 2 3 and so on) numbers of arguments from the command prompt. A simple example of a command-line argument in Kotlin. fun main(args: Array<String>) { println("Enter Two number") var (a, b) = readLine()!!.split(' ') // !! this operator use for NPE(NullPointerException). println("Max number is : ${maxNum(a.toInt(), b.toInt())}") } fun maxNum(a: Int, b: Int): Int { var max = if (a > b) { println("The value of a is $a"); a } else { println("The value of b is $b") b } return max; } Here, Enter two number from the command line to find the maximum number. Output: Enter Two number 71 89 // Enter two number from command line The value of b is 89 Max number is: 89

📄 Page 11

GoalKicker.com – Kotlin® Notes for Professionals 5 For !! Operator Please check Null Safety. Note: Above example compile and run on Intellij.

📄 Page 12

GoalKicker.com – Kotlin® Notes for Professionals 6 Chapter 2: Basics of Kotlin This topic covers the basics of Kotlin for beginners. Section 2.1: Basic examples 1. The Unit return type declaration is optional for functions. The following codes are equivalent. fun printHello(name: String?): Unit { if (name != null) println("Hello ${name}") } fun printHello(name: String?) { ... } 2. Single-Expression functions:When a function returns a single expression, the curly braces can be omitted and the body is specified after = symbol fun double(x: Int): Int = x * 2 Explicitly declaring the return type is optional when this can be inferred by the compiler fun double(x: Int) = x * 2 3. String interpolation: Using string values is easy. In java: int num=10 String s = "i =" + i; In Kotlin val num = 10 val s = "i = $num" 4. In Kotlin, the type system distinguishes between references that can hold null (nullable references) and those that can not (non-null references). For example, a regular variable of type String can not hold null: var a: String = "abc" a = null // compilation error To allow nulls, we can declare a variable as nullable string, written String?: var b: String? = "abc" b = null // ok 5. In Kotlin,== actually checks for equality of values. By convention, an expression like a == b is translated to a?.equals(b) ?: (b === null)

📄 Page 13

GoalKicker.com – Kotlin® Notes for Professionals 7 Chapter 3: Strings Section 3.1: String Equality In Kotlin strings are compared with == operator which check for their structural equality. val str1 = "Hello, World!" val str2 = "Hello," + " World!" println(str1 == str2) // Prints true Referential equality is checked with === operator. val str1 = """ |Hello, World! """.trimMargin() val str2 = """ #Hello, World! """.trimMargin("#") val str3 = str1 println(str1 == str2) // Prints true println(str1 === str2) // Prints false println(str1 === str3) // Prints true Section 3.2: String Literals Kotlin has two types of string literals: Escaped string Raw string Escaped string handles special characters by escaping them. Escaping is done with a backslash. The following escape sequences are supported: \t, \b, \n, \r, \', \", \\ and \$. To encode any other character, use the Unicode escape sequence syntax: \uFF00. val s = "Hello, world!\n" Raw string delimited by a triple quote """, contains no escaping and can contain newlines and any other characters val text = """ for (c in "foo") print(c) """ Leading whitespace can be removed with trimMargin() function. val text = """ |Tell me and I forget. |Teach me and I remember. |Involve me and I learn. |(Benjamin Franklin) """.trimMargin()

📄 Page 14

GoalKicker.com – Kotlin® Notes for Professionals 8 Default margin prefix is pipe character |, this can be set as a parameter to trimMargin; e.g. trimMargin(">"). Section 3.3: Elements of String Elements of String are characters that can be accessed by the indexing operation string[index]. val str = "Hello, World!" println(str[1]) // Prints e String elements can be iterated with a for-loop. for (c in str) { println(c) } Section 3.4: String Templates Both escaped strings and raw strings can contain template expressions. Template expression is a piece of code which is evaluated and its result is concatenated into string. It starts with a dollar sign $ and consists of either a variable name: val i = 10 val s = "i = $i" // evaluates to "i = 10" Or an arbitrary expression in curly braces: val s = "abc" val str = "$s.length is ${s.length}" // evaluates to "abc.length is 3" To include a literal dollar sign in a string, escape it using a backslash: val str = "\$foo" // evaluates to "$foo" The exception is raw strings, which do not support escaping. In raw strings you can use the following syntax to represent a dollar sign. val price = """ ${'$'}9.99 """

📄 Page 15

GoalKicker.com – Kotlin® Notes for Professionals 9 Chapter 4: Arrays Section 4.1: Generic Arrays Generic arrays in Kotlin are represented by Array<T>. To create an empty array, use emptyArray<T>() factory function: val empty = emptyArray<String>() To create an array with given size and initial values, use the constructor: var strings = Array<String>(size = 5, init = { index -> "Item #$index" }) print(Arrays.toString(a)) // prints "[Item #0, Item #1, Item #2, Item #3, Item #4]" print(a.size) // prints 5 Arrays have get(index: Int): T and set(index: Int, value: T) functions: strings.set(2, "ChangedItem") print(strings.get(2)) // prints "ChangedItem" // You can use subscription as well: strings[2] = "ChangedItem" print(strings[2]) // prints "ChangedItem" Section 4.2: Arrays of Primitives These types do not inherit from Array<T> to avoid boxing, however, they have the same attributes and methods. Kotlin type Factory function JVM type BooleanArray booleanArrayOf(true, false) boolean[] ByteArray byteArrayOf(1, 2, 3) byte[] CharArray charArrayOf('a', 'b', 'c') char[] DoubleArray doubleArrayOf(1.2, 5.0) double[] FloatArray floatArrayOf(1.2, 5.0) float[] IntArray intArrayOf(1, 2, 3) int[] LongArray longArrayOf(1, 2, 3) long[] ShortArray shortArrayOf(1, 2, 3) short[] Section 4.3: Create an array val a = arrayOf(1, 2, 3) // creates an Array<Int> of size 3 containing [1, 2, 3]. Section 4.4: Create an array using a closure val a = Array(3) { i -> i * 2 } // creates an Array<Int> of size 3 containing [0, 2, 4] Section 4.5: Create an uninitialized array val a = arrayOfNulls<Int>(3) // creates an Array<Int?> of [null, null, null] The returned array will always have a nullable type. Arrays of non-nullable items can't be created uninitialized.

📄 Page 16

GoalKicker.com – Kotlin® Notes for Professionals 10 Section 4.6: Extensions average() is defined for Byte, Int, Long, Short, Double, Float and always returns Double: val doubles = doubleArrayOf(1.5, 3.0) print(doubles.average()) // prints 2.25 val ints = intArrayOf(1, 4) println(ints.average()) // prints 2.5 component1(), component2(), ... component5() return an item of the array getOrNull(index: Int) returns null if index is out of bounds, otherwise an item of the array first(), last() toHashSet() returns a HashSet<T> of all elements sortedArray(), sortedArrayDescending() creates and returns a new array with sorted elements of current sort(), sortDescending sort the array in-place min(), max() Section 4.7: Iterate Array You can print the array elements using the loop same as the Java enhanced loop, but you need to change keyword from : to in. val asc = Array(5, { i -> (i * i).toString() }) for(s : String in asc){ println(s); } You can also change data type in for loop. val asc = Array(5, { i -> (i * i).toString() }) for(s in asc){ println(s); }

📄 Page 17

GoalKicker.com – Kotlin® Notes for Professionals 11 Chapter 5: Collections Unlike many languages, Kotlin distinguishes between mutable and immutable collections (lists, sets, maps, etc). Precise control over exactly when collections can be edited is useful for eliminating bugs, and for designing good APIs. Section 5.1: Using list // Create a new read-only List<String> val list = listOf("Item 1", "Item 2", "Item 3") println(list) // prints "[Item 1, Item 2, Item 3]" Section 5.2: Using map // Create a new read-only Map<Integer, String> val map = mapOf(Pair(1, "Item 1"), Pair(2, "Item 2"), Pair(3, "Item 3")) println(map) // prints "{1=Item 1, 2=Item 2, 3=Item 3}" Section 5.3: Using set // Create a new read-only Set<String> val set = setOf(1, 3, 5) println(set) // prints "[1, 3, 5]"

📄 Page 18

GoalKicker.com – Kotlin® Notes for Professionals 12 Chapter 6: Enum Section 6.1: Initialization Enum classes as any other classes can have a constructor and be initialized enum class Color(val rgb: Int) { RED(0xFF0000), GREEN(0x00FF00), BLUE(0x0000FF) } Section 6.2: Functions and Properties in enums Enum classes can also declare members (i.e. properties and functions). A semicolon (;) must be placed between the last enum object and the first member declaration. If a member is abstract, the enum objects must implement it. enum class Color { RED { override val rgb: Int = 0xFF0000 }, GREEN { override val rgb: Int = 0x00FF00 }, BLUE { override val rgb: Int = 0x0000FF } ; abstract val rgb: Int fun colorString() = "#%06X".format(0xFFFFFF and rgb) } Section 6.3: Simple enum enum class Color { RED, GREEN, BLUE } Each enum constant is an object. Enum constants are separated with commas. Section 6.4: Mutability Enums can be mutable, this is another way to obtain a singleton behavior: enum class Planet(var population: Int = 0) { EARTH(7 * 100000000), MARS(); override fun toString() = "$name[population=$population]" }

📄 Page 19

GoalKicker.com – Kotlin® Notes for Professionals 13 println(Planet.MARS) // MARS[population=0] Planet.MARS.population = 3 println(Planet.MARS) // MARS[population=3]

📄 Page 20

GoalKicker.com – Kotlin® Notes for Professionals 14 Chapter 7: Functions Parameter Details Name Name of the function Params Values given to the function with a name and type: Name:Type Type Return type of the function Type Argument Type parameter used in generic programming (not necessarily return type) ArgName Name of value given to the function ArgType Type specifier for ArgName ArgNames List of ArgName separated by commas Section 7.1: Function References We can reference a function without actually calling it by prefixing the function's name with ::. This can then be passed to a function which accepts some other function as a parameter. fun addTwo(x: Int) = x + 2 listOf(1, 2, 3, 4).map(::addTwo) # => [3, 4, 5, 6] Functions without a receiver will be converted to (ParamTypeA, ParamTypeB, ...) -> ReturnType where ParamTypeA, ParamTypeB ... are the type of the function parameters and `ReturnType1 is the type of function return value. fun foo(p0: Foo0, p1: Foo1, p2: Foo2): Bar { //... } println(::foo::class.java.genericInterfaces[0]) // kotlin.jvm.functions.Function3<Foo0, Foo1, Foo2, Bar> // Human readable type: (Foo0, Foo1, Foo2) -> Bar Functions with a receiver (be it an extension function or a member function) has a different syntax. You have to add the type name of the receiver before the double colon: class Foo fun Foo.foo(p0: Foo0, p1: Foo1, p2: Foo2): Bar { //... } val ref = Foo::foo println(ref::class.java.genericInterfaces[0]) // kotlin.jvm.functions.Function4<Foo, Foo0, Foo1, Foo2, Bar> // Human readable type: (Foo, Foo0, Foo1, Foo2) -> Bar // takes 4 parameters, with receiver as first and actual parameters following, in their order // this function can't be called like an extension function, though val ref = Foo::foo Foo().ref(Foo0(), Foo1(), Foo2()) // compile error class Bar { fun bar() } print(Bar::bar) // works on member functions, too. However, when a function's receiver is an object, the receiver is omitted from parameter list, because these is and only is one instance of such type.