AbstractCollection Kotlin

AbstractCollection Kotlin

欢迎使用Markdown编辑器

kotlin.collections.AbstractCollection is an abstract class that provides a basic implementation of the kotlin.collections.Collection interface. It can be used as a base class for custom collection implementations.

Here’s an example of how you might use AbstractCollection to create a custom collection:

1. Define a class that extends AbstractCollection:

class MyCustomCollection : AbstractCollection<Int>() {
    private val elements = mutableListOf<Int>()

    override val size: Int get() = elements.size

    override fun contains(element: Int): Boolean {
        return elements.contains(element)
    }

    override fun iterator(): Iterator<Int> {
        return elements.iterator()
    }

    fun addAll(c: Collection<Int>) {
        elements.addAll(c)
    }
}

2. Use the custom collection in your code:

fun main() {
    val c = MyCustomCollection()
    c.addAll(listOf(1, 2, 3))

    println(c.size) // prints "3"
    println(c.contains(2)) // prints "true"

    for (i in c) {
        println(i) // prints "1", "2", "3"
    }
}

In this example, MyCustomCollection extends AbstractCollection and provides its own implementation of the required methods (size, contains, and iterator). It also adds an additional method, addAll, for adding elements to the collection.

This is just a simple example, but you can extend AbstractCollection to create more complex collections that meet your specific needs.

Note: The AbstractCollection class is part of the Kotlin standard library, and is available in the kotlin.collections package.

AbstractCollection filter

Returns a list containing only elements matching the given predicate.

fun <T> Iterable<T>.filter(
    predicate: (T) -> Boolean
): List<T>

Here’s an example of using the filter function with a custom collection that extends AbstractCollection:

1. Define a class that extends AbstractCollection:

class MyCustomCollection3 : AbstractCollection<Int>() {
    private val elements = mutableListOf<Int>()

    override val size: Int get() = elements.size

    override fun contains(element: Int): Boolean {
        return elements.contains(element)
    }

    override fun iterator(): Iterator<Int> {
        return elements.iterator()
    }

    fun addAll(c: Collection<Int>) {
        elements.addAll(c)
    }
}

2. Use the custom collection in your code:

fun main() {
    val c = MyCustomCollection3()
    c.addAll(listOf(5, 3, 1, 4, 2))

    println(c.size) // prints "5"

    val evenNumbers = c.filter { it % 2 == 0 }
    println(evenNumbers) // prints "[2, 4]"

    val oddNumbers = c.filterNot { it % 2 == 0 }
    println(oddNumbers) // prints "[5, 3, 1]"
}

In this example, MyCustomCollection3 extends AbstractCollection and provides its own implementation of the required methods (size, contains, and iterator). It also adds an additional method, addAll, for adding elements to the collection.

The filter function is then used to create a new collection containing only the even numbers from c. The filterNot function is used to create a new collection containing only the odd numbers from c.

Note: The filter and filterNot functions are part of the Kotlin standard library, and are available in the kotlin.collections package.

AbstractCollection filterIsInstanceTo

Appends all elements matching the given predicate to the given destination.

fun <T, C : MutableCollection<in T>> Iterable<T>.filterIndexedTo(
    destination: C,
    predicate: (index: Int, T) -> Boolean
): C

Here’s an example of using the filterIsInstanceTo function with a custom collection that extends AbstractCollection:

1. Define a class that extends AbstractCollection:

class MyCustomCollection4 : AbstractCollection<Any>() {
    private val elements = mutableListOf<Any>()

    override val size: Int get() = elements.size

    override fun contains(element: Any): Boolean {
        return elements.contains(element)
    }

    override fun iterator(): Iterator<Any> {
        return elements.iterator()
    }

    fun addAll(c: Collection<Any>) {
        elements.addAll(c)
    }
}

2. Use the custom collection in your code:

fun main() {
    val c = MyCustomCollection4()
    c.addAll(listOf(5, "hello", 3, "world", 1))

    println(c.size) // prints "5"

    val ints = mutableListOf<Int>()
    c.filterIsInstanceTo(ints, Int::class.java)
    println(ints) // prints "[5, 3, 1]"

    val strings = mutableListOf<String>()
    c.filterIsInstanceTo(strings, String::class.java)
    println(strings) // prints ["hello", "world"]
}

In this example, MyCustomCollection4 extends AbstractCollection and provides its own implementation of the required methods (size, contains, and iterator). It also adds an additional method, addAll, for adding elements to the collection.

The filterIsInstanceTo function is then used to create a new collection containing only the Int elements from c, and another collection containing only the String elements from c.

Note: The filterIsInstanceTo function is part of the Kotlin standard library, and is available in the kotlin.collections package.

AbstractCollection filterNotNull

Returns a list containing all elements that are not null.

fun <T : Any> Iterable<T?>.filterNotNull(): List<T>

Here’s an example of using the filterNotNull function with a custom collection that extends AbstractCollection:

1. Define a class that extends AbstractCollection:

class MyCustomCollection5 : AbstractCollection<String?>() {
    private val elements = mutableListOf<String?>()

    override val size: Int get() = elements.size

    override fun contains(element: String?): Boolean {
        return elements.contains(element)
    }

    override fun iterator(): Iterator<String?> {
        return elements.iterator()
    }

    fun addAll(c: Collection<String?>) {
        elements.addAll(c)
    }
}

2. Use the custom collection in your code:

fun main() {
    val c = MyCustomCollection5()
    c.addAll(listOf("hello", null, "world", null, "Kotlin"))

    println(c.size) // prints "5"

    val nonNullStrings = c.filterNotNull()
    println(nonNullStrings) // prints "[hello, world, Kotlin]"
}

In this example, MyCustomCollection5 extends AbstractCollection and provides its own implementation of the required methods (size, contains, and iterator). It also adds an additional method, addAll, for adding elements to the collection.

The filterNotNull function is then used to create a new collection containing only the non-null elements from c.

Note: The filterNotNull function is part of the Kotlin standard library, and is available in the kotlin.collections package.

AbstractCollection filterTo

Appends all elements matching the given predicate to the given destination.

fun <T, C : MutableCollection<in T>> Iterable<T>.filterTo(
    destination: C,
    predicate: (T) -> Boolean
): C

Here’s an example of using the filterTo function with a custom collection that extends AbstractCollection:

1. Define a class that extends AbstractCollection:

class MyCustomCollection8 : AbstractCollection<Int>() {
    private val elements = mutableListOf<Int>()

    override val size: Int get() = elements.size

    override fun contains(element: Int): Boolean {
        return elements.contains(element)
    }

    override fun iterator(): Iterator<Int> {
        return elements.iterator()
    }

    fun addAll(c: Collection<Int>) {
        elements.addAll(c)
    }
}

2. Use the custom collection in your code:

fun main() {
    val c = MyCustomCollection8()
    c.addAll(listOf(5, 3, 1, 4, 2))

    println(c.size) // prints "5"

    val evens = mutableListOf<Int>()
    c.filterTo(evens) { it % 2 == 0 }
    println(evens) // prints "[2, 4]"

    val odds = mutableListOf<Int>()
    c.filterTo(odds) { it % 2 == 1 }
    println(odds) // prints "[5, 3, 1]"
}

In this example, MyCustomCollection8 extends AbstractCollection and provides its own implementation of the required methods (size, contains, and iterator). It also adds an additional method, addAll, for adding elements to the collection.

The filterTo function is then used to create a new collection containing only the even numbers from c, and another collection containing only the odd numbers from c.

Note: The filterTo function is part of the Kotlin standard library, and is available in the kotlin.collections package.