Docsity
Docsity

Prepare for your exams
Prepare for your exams

Study with the several resources on Docsity


Earn points to download
Earn points to download

Earn points by helping other students or get them with a premium plan


Guidelines and tips
Guidelines and tips

Kotlin, notes for professionals , Lecture notes of Civil Engineering

KotlinNotesForProfessionals.pdf

Typology: Lecture notes

2018/2019

Uploaded on 10/08/2019

maker-space
maker-space 🇹🇷

5

(1)

1 document

1 / 94

Toggle sidebar

This page cannot be seen from the preview

Don't miss anything!

bg1
Kotlin
Notes for Professionals
Kotlin®
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
pf3
pf4
pf5
pf8
pf9
pfa
pfd
pfe
pff
pf12
pf13
pf14
pf15
pf16
pf17
pf18
pf19
pf1a
pf1b
pf1c
pf1d
pf1e
pf1f
pf20
pf21
pf22
pf23
pf24
pf25
pf26
pf27
pf28
pf29
pf2a
pf2b
pf2c
pf2d
pf2e
pf2f
pf30
pf31
pf32
pf33
pf34
pf35
pf36
pf37
pf38
pf39
pf3a
pf3b
pf3c
pf3d
pf3e
pf3f
pf40
pf41
pf42
pf43
pf44
pf45
pf46
pf47
pf48
pf49
pf4a
pf4b
pf4c
pf4d
pf4e
pf4f
pf50
pf51
pf52
pf53
pf54
pf55
pf56
pf57
pf58
pf59
pf5a
pf5b
pf5c
pf5d
pf5e

Partial preview of the text

Download Kotlin, notes for professionals and more Lecture notes Civil Engineering in PDF only on Docsity!

Kotlin Notes for Professionals

Kotlin

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

Contents

Section 36.4: Dierent Kinds of Streams #7 - lazily iterate Doubles, map to Int, map to String, print each

Section 36.17: Dierent Kinds of Streams #4 - iterate an array, map the values, calculate the average ................................................................................................................................................................................ 77

Section 36.19: Dierent Kinds of Streams #6 - lazily iterate a stream of Ints, map the values, print results

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

Chapter 1: Getting started with Kotlin

Version Release Date 1.0.0 2016-02- 1.0.1 2016-03- 1.0.2 2016-05- 1.0.3 2016-06- 1.0.4 2016-09- 1.0.5 2016-11- 1.0.6 2016-12- 1.1.0 2017-03- 1.1.1 2017-03- 1.1.2 2017-04- 1.1.3 2017-06- 1.1.6 2017-11- 1.2.2 2018-01- 1.2.3 2018-03- 1.2.4 2018-04-

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) { 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.

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) {

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

For !! Operator Please check Null Safety.

Note: Above example compile and run on Intellij.

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 = str

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()

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. """

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.

val ints = intArrayOf(1, 4) println(ints.average()) // prints 2.

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 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); }

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 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 val set = setOf(1, 3, 5) println( set ) // prints "[1, 3, 5]"

println(Planet.MARS) // MARS[population=0] Planet.MARS.population = 3 println(Planet.MARS) // MARS[population=3]

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.