├── .gitignore ├── .idea ├── .gitignore ├── kotlinc.xml ├── libraries │ └── KotlinJavaRuntime.xml ├── misc.xml ├── modules.xml └── vcs.xml ├── belajar-kotlin-collection.iml └── src ├── app ├── Aggregate.kt ├── Association.kt ├── CheckingExistence.kt ├── Chunked.kt ├── Collection.kt ├── Conversion.kt ├── CustomOrdering.kt ├── DestructuringMap.kt ├── Filtering.kt ├── Flattening.kt ├── FoldReduce.kt ├── ForEach.kt ├── Grouping.kt ├── GroupingInterface.kt ├── Iterable.kt ├── List.kt ├── ListIterator.kt ├── ListOperation.kt ├── Map.kt ├── MapOperation.kt ├── Mapping.kt ├── MappingMap.kt ├── MutableCollection.kt ├── MutableIterable.kt ├── MutableList.kt ├── MutableListIterator.kt ├── MutableMap.kt ├── MutableSet.kt ├── Ordering.kt ├── Pair.kt ├── Partitioning.kt ├── PlusMinus.kt ├── PropertiesMap.kt ├── RandomOrdering.kt ├── RetrieveByCondition.kt ├── RetrieveByPosition.kt ├── RetrieveByRandom.kt ├── ReverseOrdering.kt ├── Sequence.kt ├── Set.kt ├── SetOperation.kt ├── Slice.kt ├── StringRepresentation.kt ├── TakeDrop.kt ├── Testing.kt ├── Unzip.kt ├── Windowed.kt └── Zipping.kt └── data └── Person.kt /.gitignore: -------------------------------------------------------------------------------- 1 | out -------------------------------------------------------------------------------- /.idea/.gitignore: -------------------------------------------------------------------------------- 1 | # Default ignored files 2 | /shelf/ 3 | /workspace.xml 4 | # Datasource local storage ignored files 5 | /dataSources/ 6 | /dataSources.local.xml 7 | # Editor-based HTTP Client requests 8 | /httpRequests/ 9 | -------------------------------------------------------------------------------- /.idea/kotlinc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 6 | 7 | 10 | -------------------------------------------------------------------------------- /.idea/libraries/KotlinJavaRuntime.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | -------------------------------------------------------------------------------- /.idea/misc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /.idea/modules.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /.idea/vcs.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /belajar-kotlin-collection.iml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | -------------------------------------------------------------------------------- /src/app/Aggregate.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val numbers = (1..100).toList() 5 | 6 | println(numbers.max()) 7 | println(numbers.min()) 8 | println(numbers.average()) 9 | println(numbers.sum()) 10 | 11 | println(numbers.sumBy { it / 2 }) 12 | } -------------------------------------------------------------------------------- /src/app/Association.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val list: List = listOf("Eko", "Kurniawan", "Khannedy") 5 | 6 | val map: Map = list.associate { Pair(it, it.length) } 7 | println(map) 8 | 9 | val map2: Map = list.associateWith { it.length } 10 | println(map2) 11 | 12 | val map3: Map = list.associateBy { it.length } 13 | println(map3) 14 | } -------------------------------------------------------------------------------- /src/app/CheckingExistence.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val numbers = (1..10).toSet() 5 | 6 | println(numbers.contains(5)) 7 | println(numbers.containsAll(listOf(1,2,11))) 8 | 9 | println(numbers.isEmpty()) 10 | println(numbers.isNotEmpty()) 11 | } -------------------------------------------------------------------------------- /src/app/Chunked.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val numbers = (1..100).toList() 5 | 6 | val list1 = numbers.chunked(10) 7 | println(list1.size) 8 | println(list1) 9 | 10 | val list2 = numbers.chunked(10) { values -> 11 | var total = 0 12 | for (value in values){ 13 | total += value 14 | } 15 | total 16 | } 17 | println(list2) 18 | } -------------------------------------------------------------------------------- /src/app/Collection.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun displayCollection(collection: Collection){ 4 | for (element in collection){ 5 | println(element) 6 | } 7 | } 8 | 9 | fun main() { 10 | displayCollection(listOf("Eko", "Kurniawan")) 11 | displayCollection(mutableListOf("Eko", "Kurniawan")) 12 | displayCollection(setOf("Eko", "Kurniawan")) 13 | displayCollection(mutableSetOf("Eko", "Kurniawan")) 14 | displayCollection(mapOf("Eko" to "Kurniawan").entries) 15 | // displayCollection(mapOf("Eko" to "Kurniawan")) // error, Map bukan turunan Collection 16 | } -------------------------------------------------------------------------------- /src/app/Conversion.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val array = arrayOf(3, 5, 1, 4, 67, 8, 3) 5 | val range = 1..100 6 | 7 | val list = array.toList() 8 | val set = array.toSet() 9 | 10 | val mutableSet = range.toMutableSet() 11 | val mutableList = range.toMutableList() 12 | 13 | val listToMutableList = list.toMutableList() 14 | val setToMutableSet = set.toMutableSet() 15 | 16 | val sortedSet = array.toSortedSet() 17 | } -------------------------------------------------------------------------------- /src/app/CustomOrdering.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | data class Fruit(val name: String, val quantity: Int) 4 | 5 | fun main() { 6 | val fruits = listOf( 7 | Fruit("Apple", 10), 8 | Fruit("Orange", 5), 9 | Fruit("Banana", 7) 10 | ) 11 | 12 | println(fruits.sortedBy { it.name }) 13 | println(fruits.sortedBy { it.quantity }) 14 | 15 | println(fruits.sortedByDescending { it.name }) 16 | println(fruits.sortedByDescending { it.quantity }) 17 | 18 | println( 19 | fruits.sortedWith(Comparator { fruit1, fruit2 -> 20 | fruit1.quantity.compareTo(fruit2.quantity) 21 | }) 22 | ) 23 | // fruits.sortedWith(compareBy { it.quantity }) 24 | // fruits.sortedBy { it.quantity } 25 | } -------------------------------------------------------------------------------- /src/app/DestructuringMap.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val map = mapOf( 5 | "a" to "Eko", 6 | "b" to "Kurniawan", 7 | "c" to "Khannedy" 8 | ) 9 | 10 | for((key, value) in map){ 11 | println("$key : $value") 12 | } 13 | 14 | // map.forEach { entry -> println("${entry.component1()} : ${entry.component2()}") } 15 | map.forEach { (key, value) -> println("$key : $value") } 16 | } -------------------------------------------------------------------------------- /src/app/Filtering.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val list1 = listOf("Eko", "Kurniawan", "Khannedy") 5 | val list2 = list1.filter { it.length > 5 } 6 | println(list2) 7 | val list3 = list1.filterIndexed { index, value -> index % 2 == 0 } 8 | println(list3) 9 | 10 | val list4: List = listOf(null, 1, "Eko", "Kurniawan", 2, null) 11 | val listString = list4.filterIsInstance() 12 | println(listString) 13 | val listInt = list4.filterIsInstance() 14 | println(listInt) 15 | val listNotNull = list4.filterNotNull() 16 | println(listNotNull) 17 | } -------------------------------------------------------------------------------- /src/app/Flattening.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | class Member(val name: String, val hobies: List) 4 | 5 | fun main() { 6 | val list: List> = listOf( 7 | listOf("Eko", "Kurniawan", "Khannedy"), 8 | listOf("Eko", "Kurniawan", "Khannedy"), 9 | listOf("Eko", "Kurniawan", "Khannedy"), 10 | listOf("Eko", "Kurniawan", "Khannedy") 11 | ) 12 | 13 | val listString: List = list.flatten() 14 | println(listString) 15 | 16 | val members: List = listOf( 17 | Member("Eko", listOf("Reading", "Coding")), 18 | Member("Budi", listOf("Gaming", "Traveling")) 19 | ) 20 | 21 | // val hobies = members.map { it.hobies } .flatten() 22 | val hobies: List = members.flatMap { it.hobies } 23 | println(hobies) 24 | } -------------------------------------------------------------------------------- /src/app/FoldReduce.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val numbers = (1..100).toList().shuffled() 5 | 6 | val max = numbers.reduce { first, second -> 7 | if( first > second) first 8 | else second 9 | } 10 | println(max) 11 | 12 | val min = numbers.reduce {first, second -> 13 | if(first < second) first 14 | else second 15 | } 16 | println(min) 17 | 18 | val sum = numbers.fold(0) {first, second -> 19 | first + second 20 | } 21 | println(sum) 22 | println(numbers.sum()) 23 | 24 | val names = listOf("Eko", "kurniawan", "Khannedy"); 25 | val count = names.fold(0) { first, second -> 26 | first + 1 27 | } 28 | println(count) 29 | println(names.count()) 30 | } -------------------------------------------------------------------------------- /src/app/ForEach.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | // for (value in listOf("Eko", "Kurniawan", "Khannedy")) { 5 | // println(value) 6 | // } 7 | 8 | setOf("Eko", "Kurniawan", "Khannedy").forEach { 9 | println(it) 10 | } 11 | 12 | mutableSetOf("Eko", "Kurniawan", "Khannedy").forEachIndexed { index, value -> 13 | println("$index : $value") 14 | } 15 | } -------------------------------------------------------------------------------- /src/app/Grouping.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val list = listOf("a", "b", "c", "a", "b", "c", "d", "aa", "aa", "bb", "abc") 5 | val map: Map> = list.groupBy { it } 6 | println(map) 7 | val map2: Map> = list.groupBy { it.length } 8 | println(map2) 9 | 10 | val grouping: Grouping = list.groupingBy { it } 11 | println(grouping) 12 | } -------------------------------------------------------------------------------- /src/app/GroupingInterface.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val list = listOf("a", "a", "b", "b", "c", "c", "c") 5 | val grouping: Grouping = list.groupingBy { it } 6 | 7 | println(grouping.eachCount()) 8 | val fold = grouping.fold(""){first, second -> first + second} 9 | println(fold) 10 | 11 | val reduce = grouping.reduce { key, first, second -> first + second } 12 | println(reduce) 13 | 14 | val aggregate = grouping.aggregate { key, first: String?, second, isFirst -> 15 | if(isFirst) second 16 | else first + second 17 | } 18 | println(aggregate) 19 | } -------------------------------------------------------------------------------- /src/app/Iterable.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun displayIterable(iterable: Iterable) { 4 | // for (value in iterable) { 5 | // println(value) 6 | // } 7 | 8 | val iterator = iterable.iterator() 9 | while (iterator.hasNext()){ 10 | val value = iterator.next() 11 | println(value) 12 | } 13 | } 14 | 15 | fun main() { 16 | displayIterable(listOf("Eko", "Kurniawan", "Khannedy")) 17 | displayIterable(setOf("Eko", "Kurniawan", "Khannedy")) 18 | } -------------------------------------------------------------------------------- /src/app/List.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val list: List = listOf("Eko", "Kurniawan", "Khannedy") 5 | 6 | println(list[0]) 7 | println(list[1]) 8 | println(list[2]) 9 | println(list.indexOf("Kurniawan")) 10 | println(list.indexOf("Tidak Ada")) 11 | println(list.contains("Eko")) 12 | println(list.contains("Tidak Ada")) 13 | println(list.containsAll(listOf("Eko", "Khannedy"))) 14 | println(list.isEmpty()) 15 | println(list.isNotEmpty()) 16 | } -------------------------------------------------------------------------------- /src/app/ListIterator.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun displayListIterator(listIterator: ListIterator) { 4 | println("Display Next") 5 | while (listIterator.hasNext()) { 6 | println(listIterator.next()) 7 | } 8 | 9 | println("Display Previous") 10 | while (listIterator.hasPrevious()) { 11 | println(listIterator.previous()) 12 | } 13 | } 14 | 15 | fun main() { 16 | displayListIterator(listOf("Eko", "Kurniawan", "Khannedy").listIterator()) 17 | } -------------------------------------------------------------------------------- /src/app/ListOperation.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val list = listOf("Eko", "Kurniawan", "Khannedy") 5 | 6 | println(list.getOrNull(10)) 7 | println(list.getOrElse(10){index -> "Tidak Ada"}) 8 | 9 | println(list.subList(0, 2)) 10 | 11 | val sortedList = list.sorted() 12 | println(sortedList) 13 | println(sortedList.binarySearch("Eko")) 14 | println(sortedList.binarySearch("Khannedy")) 15 | println(sortedList.binarySearch("Kurniawan")) 16 | 17 | val numbers = listOf(1,1,2,2,3,3,4,4,5,5) 18 | println(numbers.indexOf(2)) 19 | println(numbers.lastIndexOf(2)) 20 | println(numbers.indexOfFirst { it > 3 }) 21 | println(numbers.indexOfLast { it > 3 }) 22 | } -------------------------------------------------------------------------------- /src/app/Map.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val map: Map = mapOf( 5 | Pair("a", "Eko"), 6 | "b" to "Kurniawan", 7 | "c" to "Khannedy" 8 | ) 9 | 10 | for ((key, value) in map) { 11 | println("$key to $value") 12 | } 13 | } -------------------------------------------------------------------------------- /src/app/MapOperation.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val map = mapOf("a" to "Eko", "b" to "Kurniawna", "c" to "Khannedy") 5 | 6 | // println(map.getValue("tidak ada")) // exception 7 | println(map.getValue("a")) 8 | println(map.getOrElse("tidak ada") { "Ups" }) 9 | println(map.filter { entry -> entry.value.length > 5 }) 10 | println(map.filterKeys { it != "b" }) 11 | println(map.filterValues { it.length > 5 }) 12 | } -------------------------------------------------------------------------------- /src/app/Mapping.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val list: List = listOf("Eko", "Kurniawan", "Khannedy") 5 | 6 | // val temp = mutableListOf() 7 | // for(value in list){ 8 | // temp.add(value.toUpperCase()) 9 | // } 10 | 11 | // val list2 = list.map { value -> value.toUpperCase() } 12 | val list2 = list.map { it.toUpperCase() } 13 | println(list2) 14 | 15 | val set1 = setOf("Eko", "Kurniawan", "Khannedy") 16 | val set2 = set1.map { it.toLowerCase() } 17 | println(set2) 18 | 19 | val names = listOf("Eko", "Budi", "Joko", "Dani", "Andi", "Hendri") 20 | val namesGanjil = names.mapIndexedNotNull { index, name -> 21 | if (index % 2 == 0) null 22 | else name 23 | } 24 | println(namesGanjil) 25 | 26 | val numbers = (1..100).toList() 27 | val ganjil = numbers.mapNotNull { 28 | if(it % 2 == 0) null 29 | else it 30 | } 31 | println(ganjil) 32 | } -------------------------------------------------------------------------------- /src/app/MappingMap.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val map: Map = mapOf( 5 | 1 to "Eko", 6 | 2 to "Kurniawna", 7 | 3 to "Khannedy" 8 | ) 9 | 10 | val mapKeys = map.mapKeys { it.key * 10 } 11 | println(mapKeys) 12 | 13 | val mapValues = map.mapValues { it.value.toUpperCase() } 14 | println(mapValues) 15 | } -------------------------------------------------------------------------------- /src/app/MutableCollection.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun displayMutableCollection(collection: MutableCollection){ 4 | for (element in collection){ 5 | println(element) 6 | } 7 | } 8 | 9 | fun main() { 10 | // displayMutableCollection(listOf("Eko", "Kurniawan")) // ERROR 11 | displayMutableCollection(mutableListOf("Eko", "Kurniawan")) 12 | // displayMutableCollection(setOf("Eko", "Kurniawan")) // ERROR 13 | displayMutableCollection(mutableSetOf("Eko", "Kurniawan")) 14 | // displayMutableCollection(mapOf("Eko" to "Kurniawan").entries) // ERROR 15 | displayMutableCollection(mutableMapOf("Eko" to "Kurniawan").entries) 16 | } -------------------------------------------------------------------------------- /src/app/MutableIterable.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun displayMutableIterable(iterable: MutableIterable) { 4 | // for (value in iterable) { 5 | // println(value) 6 | // } 7 | 8 | val iterator = iterable.iterator() 9 | while (iterator.hasNext()){ 10 | val value = iterator.next() 11 | // iterator.remove() // menghapus data di iterasi saat ini 12 | println(value) 13 | } 14 | } 15 | 16 | fun main() { 17 | displayMutableIterable(mutableListOf("Eko", "Kurniawan", "Khannedy")) 18 | displayMutableIterable(mutableListOf("Eko", "Kurniawan", "Khannedy")) 19 | } -------------------------------------------------------------------------------- /src/app/MutableList.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val mutableList: MutableList = mutableListOf() 5 | 6 | mutableList.add("Eko") 7 | mutableList.add("Kurniawan") 8 | mutableList.add("Khannedy") 9 | 10 | // mutableList[0] = "Budi" 11 | // mutableList.remove("Eko") 12 | 13 | for (value in mutableList) { 14 | println(value) 15 | } 16 | } -------------------------------------------------------------------------------- /src/app/MutableListIterator.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun displayMutableListIterator(mutableListIterator: MutableListIterator) { 4 | while (mutableListIterator.hasNext()) { 5 | println(mutableListIterator.next()) 6 | } 7 | } 8 | 9 | fun removeOddNumber(mutableListIterator: MutableListIterator) { 10 | while (mutableListIterator.hasNext()) { 11 | val value = mutableListIterator.next() 12 | if (value % 2 == 1) { 13 | mutableListIterator.remove() 14 | } 15 | } 16 | } 17 | 18 | fun main() { 19 | val mutableList = mutableListOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) 20 | removeOddNumber(mutableList.listIterator()) 21 | displayMutableListIterator(mutableList.listIterator()) 22 | } -------------------------------------------------------------------------------- /src/app/MutableMap.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val mutableMap: MutableMap = mutableMapOf() 5 | mutableMap.put("a", "Eko") 6 | mutableMap["b"] = "Kurniawan" 7 | mutableMap["c"] = "Khannedy" 8 | 9 | println(mutableMap["a"]) 10 | println(mutableMap.get("b")) 11 | println(mutableMap.get("c")) 12 | println(mutableMap.getOrDefault("d", "Tidak Ada")) 13 | println(mutableMap.get("d")) 14 | 15 | mutableMap.remove("b") 16 | 17 | for ((key, value) in mutableMap) { 18 | println("$key to $value") 19 | } 20 | } -------------------------------------------------------------------------------- /src/app/MutableSet.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | import data.Person 4 | 5 | fun main() { 6 | val mutableSet: MutableSet = mutableSetOf() 7 | mutableSet.add(Person("Eko")) 8 | mutableSet.add(Person("Kurniawan")) 9 | mutableSet.add(Person("Khannedy")) 10 | mutableSet.add(Person("Eko")) 11 | mutableSet.add(Person("Khannedy")) 12 | 13 | for (person in mutableSet) { 14 | println(person) 15 | } 16 | 17 | val mutableSetString = mutableSetOf("Eko", "Kurniawan", "Khannedy") 18 | } -------------------------------------------------------------------------------- /src/app/Ordering.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val numbers = listOf(1, 4, 3, 2, 5, 6, 8, 3, 4, 5) 5 | 6 | val sortedAsc = numbers.sorted() 7 | val sortedDesc = numbers.sortedDescending() 8 | 9 | println(sortedAsc) 10 | println(sortedDesc) 11 | } -------------------------------------------------------------------------------- /src/app/Pair.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val pair1: Pair = Pair("Eko", "Kurniawan") 5 | println(pair1.first) 6 | println(pair1.second) 7 | 8 | val pair2: Pair = "Eko" to "Kurniawan" 9 | println(pair2.first) 10 | println(pair2.second) 11 | } -------------------------------------------------------------------------------- /src/app/Partitioning.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val list: List = listOf("Eko", "Kurniawan", "Khannedy") 5 | 6 | // val pair: Pair, List> = list.partition { it.length > 5 } 7 | val (listMatch, listNotMatch) = list.partition { it.length > 5 } 8 | 9 | println(listMatch) 10 | println(listNotMatch) 11 | } -------------------------------------------------------------------------------- /src/app/PlusMinus.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val list1 = listOf("Eko", "Kurniawan", "Khannedy") 5 | val list2 = list1 + "Programmer" 6 | println(list2) 7 | val list3 = list1 + listOf("Programmer", "Zaman", "Now") 8 | println(list3) 9 | val list4 = list1 - "Eko" 10 | println(list4) 11 | val list5 = list1 - listOf("Eko", "Khannedy", "Budi") 12 | println(list5) 13 | 14 | val map1 = mapOf("a" to "Eko", "b" to "Kurniawan") 15 | val map2 = map1 + ("c" to "Khannedy") 16 | println(map2) 17 | val map3 = map1 - "a" 18 | println(map3) 19 | } -------------------------------------------------------------------------------- /src/app/PropertiesMap.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | class Application(map: Map){ 4 | val name: String by map 5 | val version: Int by map 6 | } 7 | 8 | fun main() { 9 | val map = mapOf( 10 | "name" to "Belajar Kotlin", 11 | "version" to 1.0 12 | ) 13 | 14 | val application = Application(map) 15 | 16 | println(application.name) 17 | println(application.version) 18 | } -------------------------------------------------------------------------------- /src/app/RandomOrdering.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val numbers = (1..10).toList() 5 | 6 | println(numbers.shuffled()) 7 | println(numbers.shuffled()) 8 | println(numbers.shuffled()) 9 | println(numbers.shuffled()) 10 | println(numbers.shuffled()) 11 | println(numbers) 12 | } -------------------------------------------------------------------------------- /src/app/RetrieveByCondition.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val numbers = (1..20).toList() 5 | 6 | println(numbers.first { it > 10 }) 7 | println(numbers.last { it > 10 }) 8 | println(numbers.firstOrNull { it > 50 }) 9 | println(numbers.find { it > 50 }) 10 | println(numbers.lastOrNull { it > 50 }) 11 | println(numbers.findLast { it > 50 }) 12 | } -------------------------------------------------------------------------------- /src/app/RetrieveByPosition.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val set = setOf("Eko", "Kurniawan", "Khannedy") 5 | 6 | println(set.elementAt(0)) 7 | println(set.first()) 8 | println(set.last()) 9 | println(set.elementAtOrNull(2)) 10 | println(set.elementAtOrNull(10)) 11 | println(set.elementAtOrElse(2) { "Tidak Ada" }) 12 | println(set.elementAtOrElse(10) { "Tidak Ada" }) 13 | } -------------------------------------------------------------------------------- /src/app/RetrieveByRandom.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val numbers = (1..100).toList() 5 | 6 | println(numbers.random()) 7 | println(numbers.random()) 8 | println(numbers.random()) 9 | println(numbers.random()) 10 | println(numbers.random()) 11 | } -------------------------------------------------------------------------------- /src/app/ReverseOrdering.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val list = mutableListOf("Eko", "Kurniawan", "Khannedy") 5 | 6 | val listReversed = list.reversed() 7 | val listAsReversed = list.asReversed() 8 | 9 | println(listReversed) 10 | println(listAsReversed) 11 | 12 | list.add("Programmer") 13 | 14 | println(listReversed) 15 | println(listAsReversed) 16 | } -------------------------------------------------------------------------------- /src/app/Sequence.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val words = "the quick brown fox jumps over the lazy dog".split(" ") 5 | 6 | val result = words 7 | .filter { 8 | println("filter $it") 9 | it.length > 3 10 | } 11 | .map { 12 | println("map $it") 13 | it.toUpperCase() 14 | } 15 | .take(4) 16 | 17 | println(result) 18 | 19 | println("===============") 20 | 21 | val sequence = words.asSequence() 22 | 23 | val resultSequence = sequence 24 | .filter { 25 | println("filter $it") 26 | it.length > 3 27 | } 28 | .map { 29 | println("map $it") 30 | it.toUpperCase() 31 | } 32 | .take(4) 33 | 34 | println(resultSequence.toList()) 35 | 36 | } -------------------------------------------------------------------------------- /src/app/Set.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | import data.Person 4 | 5 | fun main() { 6 | val set: Set = setOf( 7 | Person("Eko"), Person("Kurniawan"), Person("Khannedy"), Person("Eko"), Person("Kurniawan") 8 | ) 9 | 10 | println(set.size) 11 | println(set.contains(Person("Eko"))) 12 | 13 | for (person in set){ 14 | println(person) 15 | } 16 | } -------------------------------------------------------------------------------- /src/app/SetOperation.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val numbers1 = (1..10).toSet() 5 | val numbers2 = (6..15).toSet() 6 | 7 | println(numbers1.union(numbers2)) 8 | 9 | println(numbers1.intersect(numbers2)) 10 | 11 | println(numbers1.subtract(numbers2)) 12 | println(numbers2.subtract(numbers1)) 13 | 14 | } -------------------------------------------------------------------------------- /src/app/Slice.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val numbers = (0..100).toList() 5 | 6 | val list1 = numbers.slice(0..50) 7 | println(list1) 8 | 9 | val list2 = numbers.slice(0..100 step 2) 10 | println(list2) 11 | 12 | val list3 = numbers.slice(100 downTo 0 step 2) 13 | println(list3) 14 | } -------------------------------------------------------------------------------- /src/app/StringRepresentation.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | import java.lang.StringBuilder 4 | 5 | fun main() { 6 | val list: List = listOf("Eko", "Kurniawan", "Khannedy") 7 | 8 | val string1: String = list.joinToString(" ", "|", "|") 9 | println(string1) 10 | 11 | val string2: String = list.joinToString(" ", "|", "|") { it.toUpperCase() } 12 | println(string2) 13 | 14 | val builder = StringBuilder() 15 | list.joinTo(builder, " ", "|", "|") 16 | list.joinTo(builder, " ", ">", "<") 17 | list.joinTo(builder, " ", "@", "@") 18 | val string3 = builder.toString() 19 | println(string3) 20 | 21 | val numbers: List = (1..10).toList() 22 | println(numbers.joinToString()) 23 | } -------------------------------------------------------------------------------- /src/app/TakeDrop.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val chars: List = ('a'..'z').toList() 5 | 6 | println(chars.take(3)) 7 | println(chars.takeLast(3)) 8 | println(chars.takeWhile { it < 'f' }) 9 | println(chars.takeLastWhile { it > 'w' }) 10 | 11 | println(chars.drop(3)) 12 | println(chars.dropLast(3)) 13 | println(chars.dropWhile { it < 'f' }) 14 | println(chars.dropLastWhile { it > 'f' }) 15 | } -------------------------------------------------------------------------------- /src/app/Testing.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val list = listOf("Eko", "Kurniawan", "Khannedy") 5 | 6 | println(list.any { it.length > 5 }) 7 | println(list.none { it.length > 5 }) 8 | println(list.all { it.length > 1 }) 9 | println(list.any()) 10 | println(list.none()) 11 | } -------------------------------------------------------------------------------- /src/app/Unzip.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val list: List> = listOf( 5 | "Eko" to "Programmer", 6 | "Kurniawan" to "Zaman", 7 | "Khannedy" to "Now" 8 | ) 9 | 10 | val pair: Pair, List> = list.unzip() 11 | println(pair.first) 12 | println(pair.second) 13 | 14 | val (list1, list2) = list.unzip() 15 | println(list1) 16 | println(list2) 17 | } -------------------------------------------------------------------------------- /src/app/Windowed.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val numbers = listOf(1, 2, 3, 4, 5) 5 | 6 | println(numbers.windowed(3, 1, false)) 7 | println(numbers.windowed(3, 1, false) { it.size }) 8 | println(numbers.windowed(3, 1, true)) 9 | println(numbers.windowed(3, 1, true) { it.size }) 10 | 11 | println(numbers.windowed(3, 2, false)) 12 | println(numbers.windowed(3, 2, true)) 13 | } -------------------------------------------------------------------------------- /src/app/Zipping.kt: -------------------------------------------------------------------------------- 1 | package app 2 | 3 | fun main() { 4 | val list1: List = listOf("Eko", "Kurniawan", "Khannedy") 5 | val list2: List = listOf("Programmer", "Zaman", "Now") 6 | 7 | val list3: List> = list1.zip(list2) 8 | println(list3) 9 | 10 | val list4: List = list1.zip(list2){ value1, value2 -> 11 | "$value1 $value2" 12 | } 13 | println(list4) 14 | } -------------------------------------------------------------------------------- /src/data/Person.kt: -------------------------------------------------------------------------------- 1 | package data 2 | 3 | class Person(val name: String) { 4 | 5 | override fun hashCode(): Int { 6 | return name.hashCode() 7 | } 8 | 9 | override fun equals(other: Any?): Boolean = when(other){ 10 | is Person -> name == other.name 11 | else -> false 12 | } 13 | 14 | override fun toString(): String { 15 | return "Person with name $name" 16 | } 17 | 18 | } --------------------------------------------------------------------------------