streamalism.org

1. Inleiding

Een bereik is een reeks waarden gedefinieerd door een begin, een einde en een stap.

In deze korte tutorial zullen we bekijken hoe we bereiken in Kotlin kunnen definiëren en gebruiken.

2. Kotlin Ranges gebruiken

In Kotlin kunnen we bereiken maken met behulp van de rangeTo () en downTo () functies of de .. operator.

We kunnen bereiken voor elk vergelijkbaar type gebruiken.

Standaard zijn ze inclusief, wat betekent dat de uitdrukking 1..4 overeenkomt met de waarden 1,2,3 en 4.

Daarnaast, er is nog een standaard: de afstand tussen twee waarden, een stap genoemd, met een impliciete waarde van 1.

Laten we nu eens kijken naar een paar voorbeelden van het maken van bereiken en het gebruik van andere handige methoden om ze te manipuleren.

2.1. Bereiken creëren

Bereiken implementeren een gemeenschappelijke interface - Gesloten bereik. Het resultaat van een Gesloten bereik is een progressie (zoals Int-progressie, lange progressie, of CharProgression).

Deze progressie bevat een begin, een inclusief einde en een stap en het is een subtype van Herhaalbaar waar N is Int, Long of Char.

Laten we beginnen met het bekijken van de eenvoudigste manier om een ​​bereik te maken, met behulp van de ".." en in operators:

(ik in 1..9)

Als we een achterwaarts bereik willen definiëren, kunnen we ook de downTo operator:

(i in 9 omlaag naar 1) 

We kunnen deze uitdrukking ook gebruiken als onderdeel van een als instructie om te controleren of een waarde tot een bereik behoort:

if (3 in 1..9) print ("ja")

2.2. Itererende bereiken

Nu, hoewel we bereiken kunnen gebruiken met iets vergelijkbaars, als we willen herhalen, dan hebben we een integraal typebereik nodig.

Laten we nu eens kijken naar de code om een ​​reeks te herhalen:

for (i in 1.rangeTo (9)) {print (i) // Print 123456789} voor (i in 9.downTo (1)) {print (i) // Print 987654321}

Hetzelfde gebruik is van toepassing op tekens:

for (ch in 'a' .. 'f') {print (ch) // Print abcdef} for (ch in 'f' downTo 'a') {print (ch) // Print fedcba}

3. Met behulp van de step () Functie

Het gebruik van de stap() functie is redelijk intuïtief: we kunnen het gebruiken om een ​​afstand te definiëren tussen de waarden van het bereik:

for (i in 1..9 step 2) {print (i) // Print 13579} for (i in 9 downTo 1 step 2) {print (i) // Print 97531}

In dit voorbeeld herhalen we voorwaarts en achterwaarts door de waarden van 1-9, met een stapwaarde van 2.

4. Gebruik de omgekeerd() Functie

Zoals de naam doet vermoeden, is de omgekeerd() functie zal de volgorde van het bereik omkeren:

(1..9) .reversed (). ForEach {print (it) // Print 987654321} (1..9) .reversed (). Step (3) .forEach {print (it) // Print 963}

5. Gebruik de tot() Functie

Als we een bereik willen maken dat het eindelement uitsluit dat we kunnen gebruiken tot():

voor (i in 1 t / m 9) {print (i) // Print 12345678}

6. Het laatste,eerste,stap Elementen

Als we de eerste, de stap of de laatste waarde van het bereik moeten vinden, zijn er functies die ze naar ons terugsturen:

print ((1..9) .first) // Print 1 print ((1..9 stap 2) .step) // Print 2 print ((3..9) .omgekeerd (). last) // Print 3

7. Filterbereiken

De filter() functie retourneert een lijst met elementen die overeenkomen met een bepaald predikaat:

val r = 1..10 val f = r.filter {it -> it% 2 == 0} // Afdrukken [2, 4, 6, 8, 10]

We kunnen ook andere functies toepassen zoals kaart() en verminderen() naar ons assortiment:

val m = r.map {it -> it * it} // Afdrukken [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] val rdc = r.reduce {a, b -> a + b} // Afdrukken 55 

8. Andere hulpprogramma-functies

Er zijn nog veel meer functies die we op ons assortiment kunnen toepassen, zoals min, max, som, gemiddelde, aantal, onderscheiden:

val r = 1..20 print (r.min ()) // Print 1 print (r.max ()) // Print 20 print (r.sum ()) // Print 210 print (r.average () ) // Print 10.5 print (r.count ()) // Print 20 val herhaald = listOf (1, 1, 2, 4, 4, 6, 10) print (herhaald.distinct ()) // Print [1, 2, 4, 6, 10] 

9. Aangepaste objecten

Het is ook mogelijk om een ​​reeks over aangepaste objecten te maken. Daarvoor is de enige vereiste om het Vergelijkbaar koppel.

Een opsomming is een goed voorbeeld. Alle opsommingen in Kotlin worden verlengd Vergelijkbaar wat betekent dat de elementen standaard worden gesorteerd in de volgorde waarin ze verschijnen.

Laten we een snelle maken Kleur opsomming:

opsommingsklasse Kleur (val rgb: Int): Vergelijkbaar {BLAUW (0x0000FF), GROEN (0x008000), ROOD (0xFF0000), MAGENTA (0xFF00FF), GEEL (0xFFFF00); } 

En gebruik het dan in sommige als uitspraken:

val range = red..yellow if (range.contains (Color.MAGENTA)) println ("true") // Print true if (Color.RED in Color.GREEN..Color.YELLOW) println ("true") / / Print true if (Color.RED! In Color.MAGENTA..Color.YELLOW) println ("true") // Print true

Omdat dit echter geen integraal type is, kunnen we er niet over herhalen. Als we het proberen, krijgen we een compilatiefout:

fun main (args: Array) {for (c in Color.BLUE.rangeTo (Color.YELLOW)) println (c) // for-loop range moet een iterator () methode hebben}

En als we een aangepast bereik willen hebben dat we kunnen herhalen, hoeven we het alleen maar te implementeren Gesloten bereik net zoals Iterator.

10. Conclusie

In dit artikel hebben we laten zien hoe we bereikuitdrukkingen in Kotlin kunnen gebruiken en verschillende functies die we kunnen toepassen.

Zoals altijd is de broncode beschikbaar op GitHub.