在Kotlin开发中如何使用集合详解

/**
* Returns a list containing only elements matching the given [predicate].
*/
public inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T> {
 return filterTo(ArrayList<T>(), predicate)
}

val originalList = listOf(1, 2, 3, 4, 5, 6)
assertEquals(listOf(2, 4, 6), originalList.filter { it % 2 == 0 })
val originalList = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val result = originalList.firstOrNull { it > 4 }
assertEquals(result, 5)
val originalList = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val result = originalList.getOrElse(12) { 12 }
assertEquals(result, 12)
val originalList = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val result = originalList.dropWhile { it < 5 }
assertEquals(result, listOf(5, 6, 7, 8, 9, 10))
val originalList = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val result = originalList
    .dropWhile { it < 5 }
    .find { it < 7 }
assertEquals(result, 5)

/** Returns a new read-only list of given elements. The returned list is serializable (JVM). */
public fun <T> listOf(vararg elements: T): List<T> = if (elements.size > 0) elements.asList() else emptyList()

val list = ArrayList<String>()

val list: kotlin.collections.List<String> = java.util.ArrayList()

public interface List<out E> : Collection<E> {
 // Query Operations
 override val size: Int
 override fun isEmpty(): Boolean
 override fun contains(element: @UnsafeVariance E): Boolean
 override fun iterator(): Iterator<E>

 // Bulk Operations
 override fun containsAll(elements: Collection<@UnsafeVariance E>): Boolean

 // Positional Access Operations
 /**
 * Returns the element at the specified index in the list.
 */
 public operator fun get(index: Int): E

 // Search Operations
 /**
 * Returns the index of the first occurrence of the specified element in the list, or -1 if the specified
 * element is not contained in the list.
 */
 public fun indexOf(element: @UnsafeVariance E): Int

 /**
 * Returns the index of the last occurrence of the specified element in the list, or -1 if the specified
 * element is not contained in the list.
 */
 public fun lastIndexOf(element: @UnsafeVariance E): Int

 // List Iterators
 /**
 * Returns a list iterator over the elements in this list (in proper sequence).
 */
 public fun listIterator(): ListIterator<E>

 /**
 * Returns a list iterator over the elements in this list (in proper sequence), starting at the specified [index].
 */
 public fun listIterator(index: Int): ListIterator<E>

 // View
 /**
 * Returns a view of the portion of this list between the specified [fromIndex] (inclusive) and [toIndex] (exclusive).
 * The returned list is backed by this list, so non-structural changes in the returned list are reflected in this list, and vice-versa.
 */
 public fun subList(fromIndex: Int, toIndex: Int): List<E>
}

val list: kotlin.collections.MutableList<String> = java.util.ArrayList()
list.add("string")

public interface MutableList<E> : List<E>, MutableCollection<E> {
 // Modification Operations
 override fun add(element: E): Boolean
 override fun remove(element: E): Boolean

 // Bulk Modification Operations
 override fun addAll(elements: Collection<E>): Boolean

 /**
 * Inserts all of the elements in the specified collection [elements] into this list at the specified [index].
 *
 * @return `true` if the list was changed as the result of the operation.
 */
 public fun addAll(index: Int, elements: Collection<E>): Boolean
 override fun removeAll(elements: Collection<E>): Boolean
 override fun retainAll(elements: Collection<E>): Boolean
 override fun clear(): Unit

 // Positional Access Operations
 /**
 * Replaces the element at the specified position in this list with the specified element.
 *
 * @return the element previously at the specified position.
 */
 public operator fun set(index: Int, element: E): E

 /**
 * Inserts an element into the list at the specified [index].
 */
 public fun add(index: Int, element: E): Unit

 /**
 * Removes an element at the specified [index] from the list.
 *
 * @return the element that has been removed.
 */
 public fun removeAt(index: Int): E

 // List Iterators
 override fun listIterator(): MutableListIterator<E>
 override fun listIterator(index: Int): MutableListIterator<E>

 // View
 override fun subList(fromIndex: Int, toIndex: Int): MutableList<E>
}

val list: kotlin.collections.List<String> = java.util.ArrayList()

@file:kotlin.jvm.JvmMultifileClass
@file:kotlin.jvm.JvmName("CollectionsKt")
package kotlin.collections
import kotlin.comparisons.compareValues

java.util.List<Integer> list = kotlin.collections.CollectionsKt.listOf(3, 4, 5);
java.util.List<Integer> filteredList = CollectionsKt.filter(list, item -> item > 4);