Kotlin Koleksiyonlar

KOTLIN GELİŞTİRME HAKKINDA

Kotlin ile android uygulaması geliştirmek Java geliştiricileri arasında popülerlik kazanıyor. 

Bu konu, elbette Kotlin ile başa çıkmak ve eğilimlerin ön saflarında yer almak için ciddi niyeti olan tecrübeli geliştiriciler için geçerlidir. Kotlin’deki koleksiyonları birlikte nasıl kullanacağımıza bakalım, heyecan verici olacak!

Kotlin’in Koleksiyonları Java Koleksiyon Çerçevesine dayanmaktadır . Bu makale kotlin.collections paketinin bazı özelliklerine odaklanmaktadır .

VERİ İŞLEME

Kotlin, Kotlin Standard Library’nin (stdlib) JDK sınıflarının işlevselliğini genişletmesini sağlayan Extension Functions adlı bir özelliğe sahiptir . Örneğin, stdlib’den _Collections.kt dosyasını açarsanız, buna benzer birçok yöntem bulabilirsiniz:

/ ** 
* Yalnızca verilen [yüklem] ile eşleşen öğeleri içeren bir liste döndürür. 
* / 
public inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T> {
   return filterTo(ArrayList<T>(), predicate)
}

Bunu aldığınızda, kodunuz aşağıdaki gibi görünebilir:

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)

Filter ve dropWhile öğesinin diğer birçok operatör gibi yeni bir örnek döndürdüğünü unutmayın. Bu, orijinal Listenin değişmeden kaldığı anlamına gelir.

Başlık altında olanların daha iyi anlaşılması için listOf () işlevinin kaynak koduna bakın :

/ ** Verilen elemanların salt okunur bir listesini verir. Döndürülen liste serileştirilebilir (JVM). * / 

public fun <T> listOf(var arg elements: T): List<T> = if (elements.size > 0) elements.asList() else emptyList()

Java 8’in RxJava ve Stream API’si benzer yöntemler içerir, bu yüzden muhtemelen onlara aşina olursunuz. Android geliştiricileri Stream API’yi kullanamadığı için, RxJava for Data Handling kullanımı ile sıkça karşılaşabilirsiniz. Ancak, bu yaklaşım tamamen doğru değildir ve işte nedeni budur. Mesele şu ki, RxJava Olay işleme kütüphanesi ve Veri İşleme için kullanılmıyor . Şimdi Kotlin’i kullanabilir ve bu rahatsızlığı unutabilirsiniz.

DEĞİŞKEN KOLEKSİYONLAR

Değişmez nesne sizin için yeni geldiyse o zaman kontrol etmenizi öneririz bu dışarı ve bunu yaptıktan sonra, gidip burada .

Birçok dilin aksine, Kotlin değişken ve değişmez koleksiyonları (listeler, kümeler, haritalar vb.) Birbirinden ayırır. Koleksiyon düzenlenebilirken kesin durumlar üzerinde hassas kontrol, hataları ortadan kaldırmak ve uygun API’ler tasarlamak için kullanışlıdır.

Kotlin, Java’ya benzer bir Koleksiyon örneği oluşturmanıza olanak sağlar:

val list = ArrayList <String> ()

İşte her şey basit ve açık. Ve şimdi, bu en iyi kısım!

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

Sadece kotlin.collections için bir referans oluşturduk. Aynı zamanda değişmez bir koleksiyon. İnanmıyor musun? Sadece kaynak koduna kendi gözlerinizle bakın:

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>
}

Gördüğünüz gibi, hiçbir add () yöntemi, hiçbir remove () yöntemi veya koleksiyon içeriğini değiştirmeye izin verecek başka bir yöntem yoktur. Bu durumda, örneğin kendisi genel bir java.util.ArrayList ile aynı türdedir . İşte bir sonraki örnek:

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

Kotlin örneğini kaynak kodunda kendiniz görünseniz daha iyi:

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>
}

JAVA’NIN NAZESİNDEN FAKÜLTESİ KOTLIN LİSTESİ İÇİN EŞİT OLDUĞU NASIL KEŞFEDİN?

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

Aslında sakrosanksiyon gizemi yoktur. Kotlin Koleksiyonları, Java arayüzünü uygular. Kotlin.collections.Collection.kt dosyasına bir göz atalım. Dosyanın görseli;

Daha önce belirtildiği gibi, bu dosya Koleksiyonlar için tüm Uzantı İşlevlerini içerir. Burada, CollectionsKt sınıfı aracılığıyla tüm bu işlevleri Java’da kullanmanın mümkün olduğunu görebilirsiniz. Ayrıca işte kıymetli ithalat java.util. *;

Java kodunda ne aldığımızı kontrol edelim:

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

Artık Kotlin’in List Java ile çalıştığını ve tüm Eklenti İşlevlerine statik yöntemler olarak erişilebildiğini ayıkça görebilirsiniz.

Sonuç

Android programlama dili Kotlin, daha temiz ve daha güvenli kod yazmamıza yardımcı olabilecek zengin bir dil olduğu ortaya çıktı. Ve en güzel yanı, Java ile tamamen uyumlu olması.