Untitled
unknown
plain_text
a year ago
39 kB
9
Indexable
kotlin.controlflow.datastructure 1. collections 1.1. lists 1.1.1. Exercise.kt fun main() { sumOfList() } fun sumOfList() { val list = readln().split(" ").map { it.toInt() }.toList() println(list.sum()) } ############################# 1.1.2. List.kt fun main() { methodsAndProperties() } fun initialization() { val num = MutableList(3) {0} val cars = listOf("BMW", "Honda", "Mercedes") println(cars) // output: [BMW, Honda, Mercedes] // cars[0] = "Renault" // Error val staff = emptyList<String>() println(staff) // output: [] val names = listOf("Emma", "Kim") val list = buildList { add("Marta") addAll(names) add("Kira") } println(list) // output: [Marta, Emma, Kim, Kira] var places = listOf<String>("Paris", "Moscow", "Tokyo") // note var keyword places += "Saint-Petersburg" // reassignment, slow operation println(places) // output: [Paris, Moscow, Tokyo, Saint-Petersburg] } fun methodsAndProperties() { val partyList = listOf("Fred", "Emma", "Isabella", "James", "Olivia") println(partyList.size) println(partyList.isEmpty()) println(partyList.indices) println(partyList.indexOf("Thieu")) println(partyList.contains("Emma")) val sum = partyList.sumOf { it.length } println(sum) } fun iteration() { val participants = listOf("Fred", "Emma", "Isabella") for (participant in participants) { println("Hello $participant!") } for (index in participants.indices) { println(participants[index]) } } ################################# 1.1.3. MutableList.kt fun main() { // exercise() } fun initializing() { var cars = mutableListOf<String>() println(cars) // output: [] cars = mutableListOf("Ford", "Toyota", "Audi", "Mazda", "Tesla") println(cars) // output: [Ford, Toyota, Audi, Mazda, Tesla] cars = listOf("Ford", "Toyota").toMutableList() cars.add("Tesla") println(cars) // output: [Ford, Toyota, Tesla] } fun addingAndReplacingElements() { // MutableList has the same properties and methods as List: size, get(index), isEmpty(), indexOf(element), contains(element), and so on. // it has additional functionality for changing the contents: val products = mutableListOf("Milk", "Cheese", "Coke") products.add("Chips") products [0] = "Water" // or finalList.set(0, "Water") println(products ) // output: [Water, Cheese, Coke, Chips] val dadsProducts = listOf("Banana", "Watermelon", "Apple") products .addAll(dadsProducts) } fun removingElements() { val products = mutableListOf("Milk", "Cheese", "Coke") products.removeAt(0) println(products) // output: [Cheese, Coke] products.remove("Coke") println(products) // output: [Cheese] products.clear() println(products) // output: [] } fun exercise() { val roots = mutableListOf<Int>() val a = readln().toInt() val b = readln().toInt() val c = readln().toInt() val d = readln().toInt() for (x in 0..1000) { if (a * x * x * x + b * x * x + c * x + d == 0) { roots.add(x) } } for (x in roots) { println(x) } } ################################### 1.2. maps 1.2.1. Exercise.kt fun main() { examMarks() } fun examMarks() { val studentsMarks = mutableMapOf<String, Int>() var name = "" var score = 0 while(true) { name = readln() if (name == "stop") { break } score = readln().toInt() if (!studentsMarks.containsKey(name)) { studentsMarks[name] = score } } println(studentsMarks) } fun makeMyWishList(wishList: Map<String, Int>, limit: Int): MutableMap<String, Int> { // write here val limitWishList: MutableMap<String, Int> = wishList.filter { (_, price) -> price <= limit }.toMutableMap() return limitWishList } ################################### 1.2.2. Map.kt fun main() { mapCollection() mapInitialization() } fun mapCollection() { // A Map is an immutable collection that holds pairs of objects (keys and values) // and supports efficiently retrieving values corresponding to each key. val student = mapOf( "Thieu" to 12, "Hien" to 10, "Tung" to 12, "Quan" to 11 ) println(student) // {Thieu=1, Hieu=2, Tung=10, Quan=5} val grade = student["Thieu"] println("Thieu's grade is $grade") } fun mapElement() { // An entry in a Map is represented by the special Pair type designated for generic pairs of two values. var (name, grade) = Pair("Zhenya", 5) // easy way to get the first and the second values println("Student name is: $name And their grade is: $grade") val p = Pair(2, 3) println("${p.first} ${p.second}") // 2 3 val (first, second) = p println("$first $second") val (name2, grade2) = "Vlad" to 4 println("Student name is: $name2 And their grade is: $grade2") } fun mapInitialization() { // val staff = mapOf<String, Int>("John" to 1000) // mapOf<K, V>(vararg pairs: Pair<K, V> val staff = mapOf("Mike" to 1500) // Empty map val emptyStringToDoubleMap = emptyMap<String, Double>() // Builder function val values = mapOf<String, Int>("Second" to 2, "Third" to 3) val map = buildMap<String, Int> { this["First"] = 1 putAll(values) put("Fourth", 4) } println(map.values) } fun methodsAndProperties() { val employees = mapOf( "Mike" to 1500, "Jim" to 500, "Sara" to 1000 ) if (employees.isNotEmpty()) { println("Number of employees: ${employees.size}") println("Mike wants to earn ${employees["Mike"]}") } val isWanted = employees.containsKey("Jim") println("Does Jim want to be our employee? It's $isWanted") val isAnyoneWilling = employees.containsValue(500) println("Is anyone willing to earn $500? It's $isAnyoneWilling") } fun iterating() { val employees = mapOf( "Mike" to 1500, "Jim" to 500, "Sara" to 1000 ) for (employee in employees) println("${employee.key} ${employee.value}") for (names in employees.keys) { } for (earns in employees.values) { } for ((k, v) in employees) println("$k $v") } //fun bill(priceList: Map<String, Int>, shoppingList: MutableList<String>): Int { // // put your code here // var totalPrice = 0 // // for (product in shoppingList) { // if (priceList.containsKey(product)) { // totalPrice += priceList[product] // } // } // // return totalPrice //} ############################ 1.2.3. MutableMap.kt fun main() { removingElements() } fun introduce() { var staff = mapOf( // you cannot reassign an immutable reference, so you need to use var "John" to 500, "Mike" to 1000, "Lara" to 1300 ) staff += "Jane" to 700 // reassignment println(staff) // output: {John=500, Mike=1000, Lara=1300, Jane=700} staff = mutableMapOf( "John" to 500, "Mike" to 1000, "Lara" to 1300 ) staff["Nika"] = 999 println(staff) // output: {John=500, Mike=1000, Lara=1300, Nika=999} } fun initialization() { val students = mutableMapOf("Nika" to 19, "Mike" to 23) println(students) // output: {Nika=19, Mike=23} val mapCarsPerYear = mapOf(1999 to 30000, 2021 to 202111) val carsPerYear = mapCarsPerYear.toMutableMap() carsPerYear[2020] = 2020 println(carsPerYear) // output: {1999=30000, 2021=202111, 2020=2020}} } fun addingElements() { // MutableMap has the same properties and methods as Map: size, isEmpty(), containsKey(key), containsValue(element), and so on. val groupOfStudents = mutableMapOf<String, Int>() // empty mutable map groupOfStudents.put("John", 4) groupOfStudents["Mike"] = 5 groupOfStudents["Anastasia"] = 10 val studentsFromOregon = mapOf("Alexa" to 7) groupOfStudents.putAll(studentsFromOregon) println(groupOfStudents) // output: {John=4, Mike=5, Anastasia=10, Alexa=7} // When you try to associate a specified value in the map with a key that already exists, the existing value will be overwritten. val groceries = mutableMapOf<String, Int>() groceries["Potato"] = 5 println(groceries) // output: {Potato=5} groceries["Potato"] = 10 println(groceries) // output: {Potato=10} // You can also add an element to a map using the plusAssign operator syntax, like in the example below: groceries += mapOf("Potato" to 5) groceries += "Sprite" to 1 println(groceries) } fun removingElements() { val groceries = mutableMapOf( "Potato" to 10, "Coke" to 5, "Chips" to 7 ) groceries.remove("Potato") println(groceries) // output: {Coke=5, Chips=7} groceries.clear() println(groceries) // output: {} val cars = mutableMapOf<String, Double>() cars["Ford"] = 100.500 cars["Kia"] = 500.15 println(cars) // output: {Ford=100.5, Kia=500.15} cars -= "Kia" cars -= "Thieu" println(cars) // output: {Ford=100.5} } ####################################### 1.3. sets 1.3.1. Exercise.kt fun main() { comparison() } fun solution(strings: MutableList<String>): Set<String> { // put your code here return strings.toSet() } fun subtraction(numbers1: Set<Int>, numbers2: Set<Int>): Int { // put your code here return (numbers1 - numbers2).size } fun combination(first: Set<String>, second: Set<String>): Set<String> { // put your code here return first + second } fun comparison() { val numbers1 = setOf(8, 11, 12, 13) val numbers2 = setOf(8, 13, 12, 11) println(numbers1 == numbers2) // true val mutableList = mutableListOf(13, 8, 12) println(numbers1.containsAll(mutableList)) // true } fun evenFilter(numbers: Set<Int>): Set<Int> { // put your code here return numbers.filter { num -> num % 2 == 0 }.toSet() } fun test (elements: MutableSet<Int>, element: Int): MutableSet<Int> { // put your code here return if (elements.contains(element)) { mutableSetOf() } else { elements } } fun solution(setSource: Set<String>, listSource: MutableList<String>): MutableSet<String> { // put your code here return (setSource + listSource.toSet()).toMutableSet() } fun numberInASet() { val n = readln().toInt() val mySet = mutableSetOf<Int>() repeat(n) { mySet.add(readln().toInt()) } val m = readln().toInt() println( if (mySet.contains(m)) "YES" else "NO" ) } fun littleMoreAndLittleLess(newSet: MutableSet<String>, oldSet: Set<String>): MutableSet<String> { newSet.addAll(oldSet.filter { it.startsWith("A", ignoreCase = true) }) return newSet } ################################## 1.3.2. MutableSet.kt fun main() { } fun initialization() { val students = mutableSetOf("Joe", "Elena", "Bob") println(students) // [Joe, Elena, Bob] val points = mutableSetOf<Int>() println(points) // [] val students2 = setOf("Joe", "Elena", "Bob").toMutableSet() students2.add("Bob") println(students2) // [Joe, Elena, Bob] } fun addingElements() { // MutableSet has the same properties and methods as Set: size, isEmpty(), indexOf(element), contains(element), first(), last(), and so on. val words = mutableSetOf<String>("Apple", "Coke") val friendsWords = mutableSetOf<String>("Banana", "Coke") words.add("Phone") words.add("Controller") friendsWords.add("Phone") friendsWords.add("Pasta") friendsWords.add("Pizza") words.addAll(friendsWords) val addWords: Set<String> = words.plus("Orange") // plus() khong them vao Mutable Set cu ma tra ve mot Set moi println(words) // [Apple, Coke, Phone, Controller, Banana, Pasta, Pizza] } fun removingElements() { val groceries = mutableSetOf("Apple", "Water", "Banana", "Pen") groceries.remove("Apple") println(groceries) // [Water, Banana, Pen] val uselessGroceries = setOf("Banana", "Pen") groceries.removeAll(uselessGroceries) println(groceries) // [Water] groceries.clear() println(groceries) // [] } fun iteratingThroughElements() { val places = mutableSetOf("Saint-Petersburg", "Moscow", "Grodno", "Rome") for (place in places) { println(place) } // Saint-Petersburg // Moscow // Grodno // Rome } ###################################### 1.3.3. Set.kt /* Set is an unordered collection of elements that does not allow duplicates. It is an immutable collection */ fun main() { // introducing() // methodsAndProperties() iterating() } fun introducing() { val visitors = setOf<String>("Vlad", "Vanya", "Liza", "Liza") println(visitors) // output: [Vlad, Vanya, Liza] } fun setInitialization() { val languages = setOf("English", "Russian", "Italian") val numbers = emptySet<Int>() println(numbers) // output: [] val letters = setOf<Char>('b', 'c') val set = buildSet<Char> { add('a') addAll(letters) add('d') } println(set) // output: [a, b, c, d] } fun methodsAndProperties() { val visitors = setOf("Andrew", "Mike", "Paula", "Tanya", "Julia") println("How many people visited our cafe today? ${visitors.size}") // 2 println("Was our cafe empty today? It's ${visitors.isEmpty()}") // Was our cafe empty today? It's false println("Is it true that Tanya came? It's ${visitors.contains("Tanya")}") // Is it true that Tanya came? It's true println("And what is her index? ${visitors.indexOf("Tanya")}" ) // And her index is 3 println(visitors.first()) println(visitors.last()) println(visitors.joinToString()) val studentsOfAGroup = setOf("Bob", "Larry", "Vlad") val studentsInClass = setOf("Vlad") println("Are all the students in the group in class today? It's ${studentsInClass.containsAll(studentsOfAGroup)}") val productsList1 = setOf("Banana", "Lime", "Strawberry") val productsList2 = setOf("Strawberry") val finalProductsList1 = productsList1 + productsList2 println(finalProductsList1) // [Banana, Lime, Strawberry] val finalProductsList2 = productsList1 - productsList2 println(finalProductsList2) // [Banana, Lime] val groceries = mutableListOf("Pen", "Pineapple", "Apple", "Super Pen", "Apple", "Pen") println(groceries.toSet()) // [Pen, Pineapple, Apple, Super Pen] } fun iterating() { val visitors = setOf("Vlad", "Liza", "Vanya", "Nina") for (visitor in visitors ) { println("Hello $visitor!") } // output: // Hello Vlad! // Hello Liza! // Hello Vanya! // Hello Nina! } ######################################### 1.4. Collections.kt /* Collections are containers that support various ways to store and organize different objects and make them easily accessible. A collection usually contains a number of objects (this number may be zero) of the same type. Collections are an implementation of abstract data structures that can support the following operations: retrieving an element; removing an element; changing or replacing an element; adding a new element. However, it is important to note that operations like adding, removing, and changing elements only apply to mutable collections. Kotlin Standard Library provides the implementation for the basic types of collections: list, set, and map. All three exist in mutable and immutable variations. */ fun main() { } fun commonPropertiesAndMethods() { // size - returns the size of your collection. // contains(element) - checks if the element is in your collection. // containsAll(elements) - checks if all elements of the collection elements are in your collection. // isEmpty() - shows whether the collection is empty or not. // joinToString() - converts the collection to a string. // indexOf(element) returns the index of the first entry of the element, or -1 if the element is not in the collection. // In addition, all mutable collections have some common methods. You can use them with any mutable collection, but they cannot be used with an immutable collection: // clear() - removes all elements from the collection. // remove(element) - removes the first occurrence of an element from your collection. // removeAll(elements) - removes from your collection all elements contained in the collection elements. } ##################################### 2. datatype 2.1. array 2.1.1. Arrays.kt fun main() { // creatingArrayWithSpecifiedElements() // creatingArrayWithSpecifiedSize() // readingArrayFromInput() comparingArrays() } fun creatingArrayWithSpecifiedElements() { // Kotlin can handle many types of arrays: IntArray, LongArray, DoubleArray, FloatArray, CharArray, ShortArray, ByteArray, BooleanArray // Note that Kotlin doesn't have a default StringArray type. // To create an array of a specified type, we need to invoke a special function and pass all elements to store them together val numbers = intArrayOf(1, 2, 3, 4, 5) // It stores 5 elements of the Int type println(numbers) // [I@214c265e println(numbers.joinToString()) // 1, 2, 3, 4, 5 val characters = charArrayOf('K', 't', 'l') // It stores 3 elements of the Char type println(characters.joinToString()) // K, t, l val doubles = doubleArrayOf(1.25, 0.17, 0.4) // It stores 3 elements of the Double type println(doubles.joinToString()) // 1.25, 0.17, 0.4 } fun creatingArrayWithSpecifiedSize() { // To create an array of a certain size, we need to write its type and pass it after the type name in round brackets (the constructor) val numbers = IntArray(5) // an array of 5 integer numbers println(numbers.joinToString()) // 0, 0, 0, 0, 0 val doubles = DoubleArray(7) // an array of 7 doubles println(doubles.joinToString()) // 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 // Another option is to use the Array constructor that takes the array size and the function var num = IntArray(10) { if(it % 2 == 0) { it } else { it * 2 } } println("num: ${num.joinToString()}") // 0, 2, 2, 6, 4, 10, 6, 14, 8, 18 val onlyOne = IntArray(10) { 1 } println("Only 1: ${onlyOne.joinToString()}") val onlyMinusOne = IntArray(10).apply { fill(-1) } println("Only -1: ${onlyMinusOne.joinToString()}") } fun readingArrayFromInput() { // on each line single numbers from 1 to 5 var numbers = IntArray(5) { readln().toInt() } println(numbers.joinToString()) // 1, 2, 3, 4, 5 // read an array in a single line numbers = readln().split(" ").map { it.toInt() }.toIntArray() println(numbers.joinToString()) // Mot cach khac cho phep bo qua ngat dong va extra spaces trong input // Su dung regular expressions val regex = "\\s+".toRegex() val str = "1 2\t\t3 4\n5 6" println(str) val nums = str.split(regex).map { it.toInt() }.toTypedArray() println(nums.joinToString()) // 1, 2, 3, 4, 5, 6 } fun arraySize() { // You cannot change the size of an array, but you can modify the elements. val numbers = intArrayOf(1, 2, 3, 4, 5) println(numbers.size) // 5 } fun accessingElements() { val numbers = IntArray(3) // numbers: 0, 0, 0 numbers[0] = 1 // numbers: 1, 0, 0 numbers[1] = 2 // numbers: 1, 2, 0 numbers[2] = numbers[0] + numbers[1] // numbers: 1, 2, 3 println(numbers[0]) // 1, the first element println(numbers[2]) // 3, the last element val alphabet = charArrayOf('a', 'b', 'c', 'd') println(alphabet.first()) // 'a' println(alphabet.last()) // 'd' println(alphabet.lastIndex) // 3 } fun comparingArrays() { val numbers1 = intArrayOf(1, 2, 3, 4) val numbers2 = intArrayOf(1, 2, 3, 4) val numbers3 = intArrayOf(1, 2, 3) println(numbers1.contentEquals(numbers2)) // true println(numbers1.contentEquals(numbers3)) // false val simpleArray = intArrayOf(1, 2, 3, 4) val similarArray = intArrayOf(1, 2, 3, 4) println(simpleArray == simpleArray) // true, simpleArray points to the same object println(simpleArray == similarArray) // false, similarArray points to another object } ######################################## 2.2. booleans 2.2.1. Boolean.kt /* Trong Kotlin (va Java), khong the gan gia tri integer cho bien Boolean -> 0 khong giong nhu false */ fun main() { val t = true // t is true val f = false // f is false println(t) // true println(f) // false val b: Boolean = readlnOrNull()!!.toBoolean() // True -> true, TRuE -> true,.. println(b) println("true".toBooleanStrict()) // true // println("True".toBooleanStrict()) // program crashes println("false".toBooleanStrict()) // false // println("faLse".toBooleanStrict()) // program crashes println("true".toBooleanStrictOrNull()) // true println("false".toBooleanStrictOrNull()) // false println("faLse".toBooleanStrictOrNull()) // null val b1 = false xor false // false val b2 = false xor true // true val b3 = true xor false // true val b4 = true xor true // false } ######################################## 2.3. chartype 2.3.1. Character.kt fun main() { readCharacter() val lowerCaseLetter: Char = 'a' val upperCaseLetter: Char = 'Q' val number: Char = '1' val space: Char = ' ' val dollar: Char = '$' var ch = '\u0040' // it represents '@' println(ch) // @ } fun readCharacter() { val ch = readln().first() println(ch.isUpperCase() || ch.isDigit() && ch != '0') } fun convert() { var ch = 'a' println(ch.code) // 97 val num = 97 println(num.toChar()) // a } fun howToReadCharacters() { val ch: Char = readln().first() } fun retrievingSubsequentCharacters() { val ch1 = 'b' val ch2 = ch1 + 1 // 'c' val ch3 = ch2 - 2 // 'a' // val ch2 = 1 + ch1 // Error // val charSum = 'a' + 'b' // Error var ch = 'A' ch += 10 println(ch) // 'K' println(++ch) // 'L' println(++ch) // 'M' println(--ch) // 'L' } fun escapeSequences() { // '\n' is the newline character; // // '\t' is the tab character; // // '\r' is the carriage return character; // // '\\' is the backslash character itself; // // '\'' is the single quote mark; // // '\"' is the double quote mark. print('\t') // makes a tab print('a') // prints 'a' print('\n') // goes to a new line print('c') // prints 'c' } fun relationalOperations() { println('a' < 'c') // true println('x' >= 'z') // false println('D' == 'D') // true println('Q' != 'q') // true because capital and small letters are not the same println('A' < 'a') // true because capital Latin letters are placed before small ones } fun processingCharacters() { println('1'.isDigit()) println('A'.isLetter()) println('a'.isLetterOrDigit()) println('A'.isUpperCase()) println('b'.isLowerCase()) println(' '.isWhitespace() && '\n'.isWhitespace() && '\t'.isWhitespace()) println('e'.uppercase()) // "E" println('e'.uppercaseChar()) // 'E' } #################################### 2.4. conversion 2.4.1. Conversion.kt import kotlin.math.sqrt fun main() { // Kotlin does not permit implicit conversions to avoid precision loss or unforeseen outcomes. // For instance, a Long cannot automatically convert to an Int. val longValue = 100L //val intValue: Int = longValue bestPractices() } fun explicitTypeConversion() { // Type cast val num: Int = 100 val res: Double = sqrt(num.toDouble()) println(res) // 10.0 println(num) // 100, it is not modified val smallNum: Short = num.toShort() val bigNum: Long = num.toLong() // Khi chuyen tu loai be sang loai lon cung bat buoc phai su dung ham (Khac voi Java) val ch: Char = num.toChar() val n1: Int = ch.code val l: Long = 100_000_000_000_000 val n2: Int = l.toInt() // 276447232; type overflow println(n2) // Chu y khi convert sang kieu Short hoac Byte val floatNumber = 10f val doubleNumber = 1.0 // val shortNumber = floatNumber.toShort() // avoid this // val byteNumber = doubleNumber.toByte() // avoid this val shortNumber = floatNumber.toInt().toShort() // correct way val byteNumber = doubleNumber.toInt().toByte() // correct way // String conversion val n = 8 // Int val d = 10.09 // Double val c = '@' // Char val b = true // Boolean val s1 = n.toString() // "8" val s2 = d.toString() // "10.09" val s3 = c.toString() // "@" val s4 = b.toString() // "true" val b1 = "false".toBoolean() // false val b2 = "tru".toBoolean() // false val b3 = "true".toBoolean() // true val b4 = "TRUE".toBoolean() // true } fun bestPractices() { // Use Explicit Conversions var intValue: Int = "123".toInt() // Check for null var strOrNull: String? = null var intOrNullValue: Int? = strOrNull?.toInt() // Handle NumberFormatException var str = "abc" intOrNullValue = try { str.toInt() } catch (e: NumberFormatException) { null } // Avoid loss of precision var longValue = 1_000_000_000L intValue = longValue.toInt() // Smart Casts with is if (strOrNull is String) { println(strOrNull.length) } // Use the as? Operator for Safe Casting: Use as? to safely cast to a type and to avoid ClassCastException. // This will return null if the operation fails. var x: Any = "Kotlin" var s: String? = x as? String // s = "Kotlin" x = 1 s = x as? String // s = null } ######################################### 2.4.2. SmartCast.kt fun main() { // unsafeCastOperator() // safeCastOperator() exampleFunction1<String>(123) } fun isOperator() { val obj: Any = "Hello, Kotlin" if (obj is String) { println(obj.uppercase()) } else { println("obj is not a String") // obj !is String } // idioms in Kotlin fun processInput(input: Any) { when (input) { is Int -> println("Input is an integer") is String -> println("Input is a string") is Double -> println("Input is a double") else -> println("Unknown input") } } } fun smartCast() { // When a nullable type is checked with the is operator, // Kotlin automatically casts the object to a non-nullable type. fun printLength(obj: Any) { if (obj is String) { println(obj.length) } } } fun unsafeCastOperator() { // The as keyword is used to cast an object to a non-nullable type. // If the object cannot be cast to the specified type, the as operator throws a ClassCastException. var obj: Any = "Hello, Kotlin" var str: String = obj as String // Unsafe cast operator println(str.uppercase()) obj = 1.2 var intValue: Int = obj as Int println(intValue) // ClassCastException. } fun safeCastOperator() { // The as? operator is used to cast an object to a nullable type. // If the object cannot be cast to the specified type, the as? operator returns null. val obj: Any = 123 val str: String? = obj as? String // Safe (nullable) cast operator if (str != null) { println(str.uppercase()) } } // Generics type checks and casts // Note: actual type of a generic object is not known at runtime // Therefore, certain operations, like creating a new instance of a type parameter or // checking if a type parameter is a subtype of another class, are not possible. inline fun <reified T> exampleFunction1(obj: Any) { if (obj is T) { println("obj is an instance of type parameter T") } else { println("obj is not an instance of type parameter T") } } fun <T> exampleFunction2(obj: Any) { val tObj: T? = obj as? T if (tObj != null) { // obj can be safely cast to type parameter T } else { // obj cannot be cast to type parameter T } } ##################################### 2.4.3. TypeCoercion.kt fun main() { val num: Int = 100 val longNum: Long = 1000 val result = num + longNum // 1100, Long val bigNum: Long = 100000 val doubleNum: Double = 0.0 val bigFraction = bigNum - doubleNum // 100000.0, Double // Short and Byte val one: Byte = 1 val two: Byte = 2 val three = one + two // 3, Int val fourteen: Short = 14 val ten: Short = 10 val four = fourteen - ten // 4, Int val hundred: Short = 100 val five: Byte = 5 val zero = hundred % five // 0, Int val six: Byte = 6 val seven: Byte = 7 val eleven = (six + seven).toByte() // 11, Byte } ################################## 2.5. floatingpoint 2.5.1. FloatingPointType.kt import java.util.* fun main() { // Double val one = 1.0 val negNumber = -1.75 val pi = 3.1415 // Float val b: Float = 8.75f val e = 2.71828f val number = one + 1.5 // 2.5 val c = b + negNumber // 7, Double, the type is inferred from the context errorDuringComputation() val floatNum = readln().format(Locale.US).toFloat() println(floatNum) exploringPackages() } fun errorDuringComputation() { println(3.3 / 3) // prints 1.0999999999999999 val num = 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 println(num) // it prints 0.9999999999999999 } fun decimalSeparator() { // It is crucial to use the correct decimal separator. // The separator is locale-dependent, such as a dot for the US locale. val floatNum = readln().format(Locale.US).toFloat() } fun exploringPackages() { val a: Int = 10 println(a.inc()) } ################################# 2.6. integer 2.6.1. IntegerNumber fun main() { intAndLongIntegerType() } fun intAndLongIntegerType() { val two = 2 // Int val ten = 10 // Int val twelve = two + ten // 12 val eight = ten - two // 8 val twenty = two * ten // 20 val five = ten / two // 5 val zero = ten % two // 0, no remainder val longNumber1 = 1_000_000_000_000_000 val longNumber2: Long = 1_000_000 val longNumber3 = 1000L val result = longNumber1 + longNumber2 - longNumber3 println(result) // 1000000000999000 } /* an unsigned 8-bit integer, ranges from 0 to 255 an unsigned 16-bit integer, ranges from 0 to 65535 an unsigned 32-bit integer, ranges from 0 to 4 294 967 295 (2^32-1) an unsigned 64-bit integer, ranges from 0 to 18 446 744 073 709 551 615 (2^64-1) */ fun unsignedInteger() { val uByte: UByte = 5u val uShort: UShort = 10U val smallSize = 100u // UInt by default val smallLong = 10uL // ULong because it is marked with "uL" } ################################# 2.7. nullable 2.7.1. NullableAndNonNullable.kt fun main() { nullability() accessingNullableVariable() } fun nullability() { // There are just a few ways how NPE may occur in Kotlin: // 1. explicit call of throw NullPointerException() // 2. !! syntax // 3. bad initializations, such as constructors and superclass constructors // Every reference in Kotlin can be either nullable or not. var str: String = "abc" // non-nullable variable var name: String? = null // nullable variable println(name) } fun accessingNullableVariable() { var name: String? = null if (name != null) { print(name.length) } println(name?.length) // This ?. pair of symbols is called a safe call in Kotlin. println(name?.length ?: 0) } ################################# 2.8. string 2.8.1. StringBasics.kt fun main() { rawString() } fun lengthOfString() { val language = "Kotlin" println(language.length) // 6 } fun concatenatingString() { val one = "1" val two = "2" val twelve = one + two println(one) // 1, no changes println(two) // 2, no changes println(twelve) // 12 } fun appendingValuesToString() { val stringPlusBoolean = "abc" + 10 + true println(stringPlusBoolean) // abc10true // val errorString = 10 + "abc" // an error here! val charPlusString = 'a' + "bc" println(charPlusString) // abc val stringPlusChar = "de" + 'f' println(stringPlusChar) // def } fun repeatString() { print("Hello".repeat(4)) // HelloHelloHelloHello } fun rawString() { // escape sequences println("\'H\' is the first letter of \"Hello world!\" string.") // raw string val largeString = """ This is the house that Jack built. This is the malt that lay in the house that Jack built. This is the rat that ate the malt That lay in the house that Jack built. This is the cat That killed the rat that ate the malt That lay in the house that Jack built. """.trimIndent() // removes the first and the last lines and trims indents println(largeString) val unevenString = """ 123 456 789""".trimIndent() print(unevenString) println() val rawString = """123 456 789 """.trimIndent() print(rawString ) } ################################# 2.8.2. StringTemplates.kt fun main() { getPattern() } fun stringTemplate() { val city = "Paris" val temp = "24" println("Now, the temperature in $city is $temp degrees Celsius.") } const val month = "(JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC)" fun getPattern(): String = """\d{2} $month \d{4}""" fun templateForExpression() { val language = "Kotlin" println("$language has ${language.length} letters in the name") println("$language has $language.length letters in the name") } ################################ 2.8.3. TripleQuoted.kt const val question = "life, the universe, and everything" const val answer = 42 val tripleQuotedString = """ question = "$question" answer = $answer""".trimIndent() fun main() { println(tripleQuotedString) } ################################# 2.8.4. WorkWithStrings.kt fun main() { val array = readln().split(" ") println("${array[0][0]}. ${array[1]}, ${array[2]} years old") } fun accessCharacters() { val greeting = "Hello" val first = greeting[0] // 'H' val second = greeting[1] // 'e' val five = greeting[4] // 'o' val last = greeting[greeting.length - 1] // 'o' val prelast = greeting[greeting.length - 2] // 'l' println(greeting.first()) // 'H' println(greeting.last()) // 'o' println(greeting.lastIndex) // 4 } fun emptyString() { val emptyString = "" println(emptyString.length == 0) //true println(emptyString.isEmpty()) //true } fun immutability() { val valString = "string" // valString[3] = 'o' // an error here! var varString = "string" // varString[3] = 'o' // an error here too! varString = "strong" // legal } fun comparingStrings() { val first = "first" val second = "second" var str = "first" println(first == str) // true println(first == second) // false println(first != second) // true } ####################################### 2.9. Main.kt fun main() { // Integer val zero = 0 // Int val one = 1 // Int val oneMillion = 1_000_000 // Int val twoMillion = 2_000_000L // Long because it is tagged with L val bigNumber = 1_000_000_000_000_000 // Long, Kotlin automatically chooses it (Int is too small) val ten: Long = 10 // Long because the type is specified val shortNumber: Short = 15 // Short because the type is specified val byteNumber: Byte = 15 // Byte because the type is specified // Floating-point val pi = 3.1415 // Double val e = 2.71828f // Float because it is tagged with f val fraction: Float = 1.51f // Float because the type is specified println(Int.MIN_VALUE) // -2147483648 println(Int.MAX_VALUE) // 2147483647 println(Long.MIN_VALUE) // -9223372036854775808 println(Long.MAX_VALUE) // 9223372036854775807 println(Int.SIZE_BYTES) // 4 println(Int.SIZE_BITS) // 32 // Character val lowerCaseLetter = 'a' val upperCaseLetter = 'Q' val number = '1' val space = ' ' val dollar = '$' // Boolean val enabled = true val bugFound = false // String val creditCardNumber = "1234 5678 9012 3456" val message = "Learn Kotlin instead of Java." val greeting: String greeting = "Hello" } ####################################### 2.10. Range.kt fun main() { val a = 1 var b = 10 var c = 11 val within = c in a..b // a <= c && c <= b // a..b is a closed-ended range. // a until b is a open-ended range. println(5 in 5 until 15) // true println(15 in 5 until 15) // false var withinExclRight = c in a..b - 1 // a <= c && c < b withinExclRight = c in a until b // a <= c && c < b (the recommended way) val notWithin = 100 !in 10..99 // true val range = 10..20 // IntRange println(30 in range) // false println('b' in 'a'..'c') // true println('k' in 'a'..'e') // false println("hello" in "he".."hi") // true println("abc" !in "aab".."aac") // true } ####################################### 2.11. TypeSystem.kt /* Kotlin la ngon ngu go kieu tinh (statically-typed language), co nghia la no thuc hien kiem tra kieu trong qua trinh bien dich -> loi duoc kiem tra truoc khi chuong trinh chay -> dan den ma it loi hon va dang tin cay hon */ fun main() { staticTyping() } fun staticTyping() { // Kotlin's static typing assures that the types of variables are known at compile time, // optimising performance and improving clarity. val message: String = "Hello, Kotlin!" println(message) } fun advantagesOfTypeSystem() { // Null safety var a: String = "abc" //a = null // Compile error var b: String? = "abc" b = null // OK // Smart casts if (b is String) { println(b.length) } // Type inference: Kotlin has efficient type inference capabilities, indicating you don't always need to state the type clearly. val language = "Kotlin" // Type inferred as String // Extension Functions fun String.addExclamation() = "$this!" println("Hello".addExclamation()) // Output: Hello! }
Editor is loading...
Leave a Comment