Kotlin LongIterator

📘 Premium Read: Access my best content on Medium member-only articles — deep dives into Java, Spring Boot, Microservices, backend architecture, interview preparation, career advice, and industry-standard best practices.

✅ Some premium posts are free to read — no account needed. Follow me on Medium to stay updated and support my writing.

🎓 Top 10 Udemy Courses (Huge Discount): Explore My Udemy Courses — Learn through real-time, project-based development.

▶️ Subscribe to My YouTube Channel (172K+ subscribers): Java Guides on YouTube

Introduction

In Kotlin, LongIterator is an abstract class that simplifies the creation of iterators for Long values. This class is part of the kotlin.collections package and is typically used when you need to iterate over a collection of Long values.

Table of Contents

1. What is LongIterator?
2. Creating a LongIterator
3. Common Operations
4. Examples of LongIterator
5. Real-World Use Case
6. Conclusion

1. What is LongIterator?

LongIterator in Kotlin is an abstract class that provides a template for creating iterators specifically for Long values. It is part of the kotlin.collections package and is useful for iterating over collections of Long values.

Syntax

abstract class LongIterator : Iterator<Long> {
    abstract fun nextLong(): Long
}

2. Creating a LongIterator

To create a LongIterator, you need to extend the LongIterator class and implement the nextLong() and hasNext() methods.

Example

class MyLongIterator(private val longs: List<Long>) : LongIterator() {
    private var index = 0

    override fun hasNext(): Boolean {
        return index < longs.size
    }

    override fun nextLong(): Long {
        if (!hasNext()) throw NoSuchElementException()
        return longs[index++]
    }
}

3. Common Operations

The LongIterator class provides the following operations:

• hasNext(): Checks if there are more elements to iterate.
• nextLong(): Returns the next Long value in the iteration.

4. Examples of LongIterator

Example 1: Basic Usage of LongIterator

This example demonstrates how to create and use a custom LongIterator to iterate over a list of Long values.

fun main() {
    val longs = listOf(1L, 2L, 3L, 4L, 5L)
    val iterator = MyLongIterator(longs)

    while (iterator.hasNext()) {
        println(iterator.nextLong())
    }
}

Output:

1
2
3
4
5

Explanation:
This example creates a custom LongIterator and iterates over a list of Long values, printing each value.

Example 2: Implementing a Custom LongIterator

This example demonstrates a more detailed implementation of a custom LongIterator.

class CustomLongIterator(private val list: List<Long>) : LongIterator() {
    private var index = 0

    override fun hasNext(): Boolean {
        return index < list.size
    }

    override fun nextLong(): Long {
        if (!hasNext()) throw NoSuchElementException("No more elements")
        return list[index++]
    }
}

fun main() {
    val longList = listOf(10L, 20L, 30L)
    val longIterator = CustomLongIterator(longList)

    while (longIterator.hasNext()) {
        println(longIterator.nextLong())
    }
}

Output:

10
20
30

Explanation:
This example shows a custom implementation of LongIterator that iterates over a list of Long values and handles the NoSuchElementException when there are no more elements.

5. Real-World Use Case: Filtering Long Data

You can use LongIterator to process and filter Long data in a collection.

Example: Filtering Even Long Numbers

class EvenLongFilterIterator(private val list: List<Long>) : LongIterator() {
    private var index = 0

    override fun hasNext(): Boolean {
        while (index < list.size && list[index] % 2 != 0L) {
            index++
        }
        return index < list.size
    }

    override fun nextLong(): Long {
        if (!hasNext()) throw NoSuchElementException("No more elements")
        return list[index++]
    }
}

fun main() {
    val longList = listOf(1L, 2L, 3L, 4L, 5L, 6L)
    val evenLongFilterIterator = EvenLongFilterIterator(longList)

    while (evenLongFilterIterator.hasNext()) {
        println(evenLongFilterIterator.nextLong())
    }
}

Output:

2
4
6

Explanation:
This example uses a custom LongIterator to filter and print only the even Long values from a list of Long values.

Conclusion

LongIterator in Kotlin is a useful abstract class from the kotlin.collections package that simplifies the creation of iterators for Long values. By extending LongIterator and implementing the necessary methods, you can create custom iterators to efficiently iterate over collections of Long values.