Cấu trúc dữ liệu với Kotlin: Kỹ năng cần biết

fun main() {
    // Ngoài ra còn có thể sử dụng FloatArray, DoubleArray, LongArray, ShortArray, ByteArray, CharArray, BooleanArray
    val simpleIntegerArrayV1: IntArray = intArrayOf(1, 2, 3, 4, 5)
    simpleIntegerArrayV1[0] = 10

    // Hoặc chỉ cần sử dụng arrayOf
    val simpleIntegerArrayV2: Array<Int> = arrayOf(1, 2, 3, 4, 5)
    val simpleIntegerArrayV3: Array<Int> = Array(5) { i -> i + 1 }
    val simpleIntegerArrayV4: Array<Int> = Array(5) { it + 1 }
    val simpleIntegerArrayV5 = simpleIntegerArrayV4 + simpleIntegerArrayV3
    val simpleIntegerArrayWithNullable: Array<Int?> = arrayOf(1, 2, 3, 4, 5, null)

    simpleIntegerArrayV2.forEach {
        println(it)
    }
    simpleIntegerArrayV2.forEachIndexed { index, i ->
        println("Index: $index, Value: $i")
    }
    println(simpleIntegerArrayV5.joinTo(StringBuilder(), separator = ", ", prefix = "[", postfix = "]"))
}

fun main() {
    val greeting = "Hello"
    val completeGreeting = "$greeting, Kotlin!"
    println(completeGreeting)

    // String Interpolation
    val name = "DanTech0xFF"
    println("Hello, $name!")

    // Multiline Strings
    val text = """
        This is a multiline string.
        It spans multiple lines.
        """
    println(text)

    // String Length
    val textLength = "Hello, Kotlin Programming!"
    println("Length of the string is ${textLength.length}")

    // String to Int Conversion
    val numberString = "123"
    val number = numberString.toInt()
    println(number + 1)

    // String Comparison
    val text1 = "Hello"
    val text2 = "hello"
    println(text1.equals(text2, ignoreCase = true))

    // Substring
    val substringText = "Hello, World!"
    println(substringText.substring(0, 5))

    // Replace
    val replaceText = "Hello, Kotlin!"
    println(replaceText.replace("Kotlin", "Kotlin Programming"))
}

fun main() {
    val numbers: List<Int> = listOf(1, 2, 3, 4, 5)
    println(numbers[0]) // Output: 1
    println(numbers[1]) // Output: 2
    println(numbers.size) // Output: 5
    println(numbers.contains(3)) // Output: true
    println(numbers.indexOf(4)) // Output: 3
    println(numbers.lastIndexOf(5)) // Output: 4
    println(numbers.subList(1, 4)) // Output: [2, 3, 4]
    println(numbers.isNotEmpty())

    val mutableNumbers = mutableListOf(1, 2, 3, 4, 5) // numbers.toMutableList()
    mutableNumbers.add(6)
    mutableNumbers.removeAt(0)
    mutableNumbers[1] = 10
    println(mutableNumbers) // Output: [2, 10, 3, 4, 5, 6]
}

fun main() {
    // Deque is a double-ended queue that supports adding and removing elements from both ends
    // support both mechanisms of stack and queue
    val deque = ArrayDeque<Int>()

    // Adding elements to the deque
    deque.addFirst(1)
    deque.addLast(2)
    deque.addFirst(3)
    deque.addLast(4)

    println("Deque after adding elements: $deque")

    // Removing elements from the deque
    val removedFirst = deque.removeFirst()
    val removedLast = deque.removeLast()

    println("Removed first element: $removedFirst")
    println("Removed last element: $removedLast")
    println("Deque after removing elements: $deque")

    // Iterating over the elements
    println("Iterating over the elements:")
    for (element in deque) {
        println(element)
    }

    // Checking if deque contains a specific element
    val containsThree = deque.contains(3)
    println("Deque contains 3: $containsThree")

    // Getting the size of the deque
    val size = deque.size
    println("Size of the deque: $size")

    // Checking if the deque is empty
    val isEmpty = deque.isEmpty()
    println("Is deque empty: $isEmpty")

    // Clearing the deque
    deque.clear()
    println("Deque after clearing: $deque")
}

fun main() {
    val hashMap = mapOf(
        "key1" to "value1",
        "key2" to "value2",
        "key3" to "value3"
    ) // Immutable Map
    val mutableHashMap = mutableMapOf(
        "key1" to "value1",
        "key2" to "value2",
        "key3" to "value3"
    ) // Mutable Map
    val emptyHashMap = hashMapOf<String, String>() // Mutable empty HashMap
    val manualHashMap: HashMap<String, String> = HashMap() // Mutable empty HashMap
    val immutableHashMap: Map<String, String> = HashMap() // Immutable empty HashMap
}

fun main() {
    val hashSet = setOf("value1", "value2", "value3") // Immutable Set
    val mutableHashSet = mutableSetOf("value1", "value2", "value3") // Mutable Set
    val emptyHashSet = hashSetOf<String>() // Mutable empty HashSet
    val manualHashSet: HashSet<String> = HashSet() // Mutable empty HashSet
    val immutableHashSet: Set<String> = HashSet() // Immutable empty HashSet
}