├── .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 |
5 |
6 |
7 |
8 |
9 |
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 | }
--------------------------------------------------------------------------------