Ciclos for y foreach en Kotlin

Clase 15 de 47 • Curso Básico de Kotlin 2019

Nos adelantamos un poco y en clases anteriores aprendimos a usar el ciclo for, como viste Kotlin lo hace muy sencillo de entender pues su sintaxis es muy clara.

Veamos un grado más de complejidad en los ciclos for y además aprendamos sobre foreach.

Básicamente sabemos que un ciclo for itera o recorre una lista de elementos.

Imaginemos que tenemos la siguiente lista:

var daysOfWeek = listOf("Domingo","Lunes","Martes","Miercoles","Jueves","Viernes","Sabado")

La forma tradicional de iterarlo sería así:

for(day in daysOfWeek){
        println(day)
}

Con esto estaremos imprimiendo día por día. En algún punto del curso platicamos lo útil que a veces suele ser tener acceso índices, en Kotlin es posible tener acceso al índice de una lista recorrida en un ciclo for, podemos hacerlo con la siguiente sintaxis:

for((index,day) in daysOfWeek.withIndex()){
        println("$index :$day")
}

De esta forma podemos imprimir el día acompañado de su respectivo índice.

Foreach

Tenemos una forma de recorrer esto mismo pero con una sintaxis más simplificada, esto es utilizando un foreach, que en esencia tendrá el mismo objetivo que un for natural de Kotlin, recorrer una lista de elementos, solo que la sintaxis aquí es más clara.

Miremos la misma lista de días, recorridas con un foreach:

var daysOfWeek = listOf("Domingo","Lunes","Martes","Miercoles","Jueves","Viernes","Sabado")
daysOfWeek.forEach{
        println(it)
}

it será el iterador que contiene cada elemento de la lista mientras es recorrida.

Como vemos aparentemente ambas formas de recorrer listas parecen ser igual, sin embargo se ha comprobado que un ciclo for es 10x más rápido que uno foreach.

Comentarios

JOSE MANUEL PAREDES RAMIREZ

student•

Les dejo un articulo en el cual se compara el rendimiento. Las conclusiones son las siguientes(basadas en la velocidad):

Si es para un rango es mejor usar For
Si es para una colección (sequence, list, set) es mejor foreach
Si se va a usar break y continue es mejor For

Andres López

student•

Gracias por el artículo y el resumen. Lo pondré en mis apuntes y el artículo en mis marcadores para tenerlo de referencia

Cesar David Ramírez Dimaté

student•

Excelente este dato. Si se va afirmar por qué un for es más rápido que un forEach, por lo menos dejar al fuente y su justificación.

Joshua Chavez

student•

Una manera de utilizar el indice.

var dayOfWeek = listOf("Domingo", "Lunes", "Martes", "Miércoles", "Jueves", "Viernes", "Sábado")
    for ((index, day) in dayOfWeek.withIndex()){
        print("$day | ")
        when (index){
            in 1..5 -> println("Día laboral")
            else -> println("Fin de semana")
        }
    }```

Miguel Angel Reyes Moreno

student•

Qué buen ejemplo :)

Roy Jesús Rodriguez Montecinos

student•

Estuve revisando un poco y al parecer en el caso de listas forEach funciona de manera mas rapida que for. Utilice el siguiente codigo:

val numberList = (1..100000).toList()

println("Time spent 'for' :\t\t" + measureNanoTime {
    for (i in numberList) {

    }
})

println("Time spent 'forEach' :\t" + measureNanoTime {
    numberList.forEach {

    }
})

Time spent 'for' : 9621091 Time spent 'forEach' : 8688281

Cesar David Ramírez Dimaté

student•

Así es, todo lo explican acá,

Kotlin: For-loop vs ForEach

Rosel Miguel Castillo Romero

student•

Tambien podemos usar el forEachIndexed para obtener acceso a los indices

daysOfWeek.forEachIndexed { index, s -> println("Index $index: $s") }

Andres López

student•

No entiendo este símbolo en el código ->. Es como el arrow function en JS?

Sebastian Matias Pulido

student•

mmmm.... Debería usar val en ves de var No sea cosa que le cambien algún día de la semana XD

Sebastian CA

student•

true lol

Gerson Yesid Angel Avila

student•

Excelente información y aun más excelente los aportes y comentarios de todos

Emmanuel Rodríguez

student•

Las bondades de los objetos 🤟

Roberto Requena

student•

También Con el forEachIndexed podemos tener acceso al indice elemento de la lista al que estamos accediendo en ese momento: Ejemplo:

fun main() {
    
   var daysOfWeek = 
listOf("Domingo","Lunes","Martes","Miercoles","Jueves","Viernes","Sabado")

  daysOfWeek.forEachIndexed { index, day ->
 		println("$index :$day")
	}
}

Richard Ruiz

student•

daysOfWeek.withIndex().forEach{ println(it.index) }

Jaime Pérez García

student•

muchas gracias por el aporte

Pedro Jesus Hincapie Garcia

student•

Me tome la tarea de comprobar la afirmación realizada en este articulo y me tope con que no es asi para todos los casos

fun main(args: Array&lt;String&gt;) {
    val numeros = 1..10000
    val list = (1..10000).toList()

    val inicialFor = System.currentTimeMillis()
    for (numero in numeros) {
        //println(numero)
    }
    println(System.currentTimeMillis() - inicialFor)

    println(&quot;::::::::::::::::::::::::::::::::::::::::::::&quot;)

    val inicialForEach = System.currentTimeMillis()
    numeros.forEach {
        //println(it)
    }
    println(System.currentTimeMillis() - inicialForEach)


    println(&quot;----------------------------------------------------------------------------------&quot;)


    val inicialFor1 = System.currentTimeMillis()
    for (numero in list) {
        //println(numero)
    }
    println(System.currentTimeMillis() - inicialFor1)

    println(&quot;::::::::::::::::::::::::::::::::::::::::::::&quot;)

    val inicialForEach1 = System.currentTimeMillis()
    list.forEach {
        //println(it)
    }
    println(System.currentTimeMillis() - inicialForEach1)


}

Por medio del anterior fuente comprobé que:

Si es un rango se recomienda un for-loop.

Si es una colección se recomienda un forEach

Cesar David Ramírez Dimaté

student•

Diste muchas vueltas para algo simple. Sólo con esto era suficiente:

Rangos

println("\nIntRange")
println("ForLoop Time: " + measureNanoTime {
    for (i in 0 until 10000) { doSomething() }  // ForLoop Time: 467412. Mejor opción (para rangos).
})
println("ForEach Time: " + measureNanoTime {
    (0 until 10000).forEach { doSomething() }  // ForEach Time: 510866s.
})

Listas

println("\nList")
val listP = (1..10000).toList()

println("ForLoop Time: " + measureNanoTime {
    for (i in listP) { doSomething() }  // ForLoop Time: 786258
})
println("ForEach Time: " + measureNanoTime {
    listP.forEach { doSomething() }  // ForEach Time: 535152. Mejor opción (para cualquier colección).
})

Jordi Santamaría Portolés

student•

para que vas a usar un foreach si es 10 veces mas lento wtf.

JAIME URQUIZU

student•

Porque a la hora de recorrer un array, por ejemplo en una situación backend, un foreach resulta mucho más comprensible (y declarativo) que un for, por ejemplo para recorrer JSONs.

Cesar David Ramírez Dimaté

student•

Recuerda que depende. Un forEach es más rápido para listas, secuencias y set, pero no para rangos. Hay que leer jajaja.

Manuel Duarte

student•

Algo con el doWhile

fun main(args: Array<String>) {

    var addEmloy = true

    do {
        println("You name")
        var name = readLine()
        println("You salary")
        var salary = Integer.valueOf(readLine())
        println("Year")
        var year = Integer.valueOf(readLine())
        println("Vacation")
        var vacation = Integer.valueOf(readLine())

        var pago = salary * year
        var total = pago + (salary / 30 * vacation)

        println("$name su pago es $total")
        println("Desea agregar otro empleado (s/n)")

        var respuesta = readLine()!!.toString()
        if (respuesta == "n")
            addEmloy = false
    }
    while (addEmloy)

}

Davis Giovanni

student•

Siento que tengo mas control con el for, y al momento de hacer una prueba de escritorio presiento que seria mas facil

Marco Alexander Mateo Mateo

student•

Excelente, un emplo muy bueno para calcular el factorial de un número:

fun fact( a: Int): Double {
  var result:Double = 1.0
  for(i in a downTo 1)
    result = result*i
  return result
}

Sebastian Matias Negri

student•

Muy buena la fun! Ahora tene en cuenta que segun clases anteriores estas utilizando un tipo de datos primitivo, para kotlin seria mejor utilizar:

fun fact( a: Int): Double {
	var result: Double = 1.0
	for(i in a downTo 1)
	result = result.times(i)
	return result
}

Saludos!

Camilo Arguello

student•

Pregunta, es necesario que la función retorne tipo de dato "Double" ? Para este ejemplo pienso que podría retornar siempre Int

Luis Canchari

student•

Como se comprobó que el ciclo for es 10x mas rápido que foreach?

Andrés Felipe Arévalo Peralta

student•

Mi código para tenerlo en cuenta

 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    println("\n*/*/*/*/*/*/*/*/*/*/*/*/Operadores lógicos For y For Each*/*/*/*/*/*/*/*/*/*/*/ *")
    println("Tener en Cuenta que el FOR es 10X más rápido que el FOR EACH")
    var daysOfWeek = listOf("Domingo", "Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sábado")

    println("Forma Tradicional (FOR)")
    for (day in daysOfWeek){

        println("El dia es: $day")

    }

    println("Indices en For (FOR)")
    for ((index, day) in daysOfWeek.withIndex()){
        println("El Índice es $index y el dia es: $day")

    }

    println("forma simplificada (FOREACH)")
    daysOfWeek.forEach{

        println(it) //variable de la iteración

    }```

Sebastian Valencia Zapata

student•

El index es super útil. :0

Milton Enríquez Torres

student•

yo pensando en el usuario de que posiblemente no entenderá cual es el día 0, prefiero arreglarlo de esta forma:

fun main(args: ArrayList&lt;String&gt;){
  var daysOfWeek=listOf(&quot;Domingo&quot;,&quot;Lunes&quot;,&quot;Martes&quot;,&quot;Miercoles&quot;,&quot;Jueves&quot;,&quot;Viernes&quot;,&quot;Sabado&quot;)
    for((index,day) in daysOfWeek.withIndex())
        println(&quot;${index.plus(1)} :$day&quot;)
}

Pedro Jesus Hincapie Garcia

student•

Para los caso en donde se requiera tener acceso al índices desde un forEach, te recomiendo :

val list = listOf(&quot;Domingo&quot;,&quot;Lunes&quot;,&quot;Martes&quot;,&quot;Miercoles&quot;,&quot;Jueves&quot;,&quot;Viernes&quot;,&quot;Sabado&quot;)
 list.forEachIndexed { index, i -&gt; println(&quot;$i ------- $index&quot; ) }

Domingo ------- 0
Lunes ------- 1
Martes ------- 2
Miercoles ------- 3
Jueves ------- 4
Viernes ------- 5
Sabado ------- 6

Didio Perdomo

student•

trate de hacer las tablas de multiplicar del 1 al 10 y dio genial!

var i=1 var j =1

for (i in 1..10){
    println(&quot;Tabla del: $i&quot;)
    for (j in 1..10)
        println(&quot;$i * $j = &quot;+ i.times(j))
}

Jamilton Alonso Quintero Osorio

student•

Super curioso que el foreach sea una función super sencilla la escritura, cada vez me gusta mas kotlin.

Jair Renato Nieto Moreno

student•

Dejo los ejemplos de ciclo for, al correrlos notaran la diferencia

      //ciclo for
    var daysOfWeek = listOf("Domingo","Lunes","Martes","Miercoles","Jueves","Viernes","Sabado")
    for(day in daysOfWeek){
        println(day)
    }
    //ciclo for con indice
    for((index,day) in daysOfWeek.withIndex()) {
        when (index) {
            in 1..5 -> println("entre semana $index :$day")
            else -> println("fin semana $index :$day")

        }
    }
    //ciclo forEach
    daysOfWeek.forEach{
        println(it)
    }```

var dayOfWeek = listOf("Domingo", "Lunes", "Martes", "Miércoles", "Jueves", "Viernes", "Sábado")
    for ((index, day) in dayOfWeek.withIndex()){
        print("$day | ")
        when (index){
            in 1..5 -> println("Día laboral")
            else -> println("Fin de semana")
        }
    }```

fun main(args: Array&lt;String&gt;) {
    val numeros = 1..10000
    val list = (1..10000).toList()

    val inicialFor = System.currentTimeMillis()
    for (numero in numeros) {
        //println(numero)
    }
    println(System.currentTimeMillis() - inicialFor)

    println(&quot;::::::::::::::::::::::::::::::::::::::::::::&quot;)

    val inicialForEach = System.currentTimeMillis()
    numeros.forEach {
        //println(it)
    }
    println(System.currentTimeMillis() - inicialForEach)


    println(&quot;----------------------------------------------------------------------------------&quot;)


    val inicialFor1 = System.currentTimeMillis()
    for (numero in list) {
        //println(numero)
    }
    println(System.currentTimeMillis() - inicialFor1)

    println(&quot;::::::::::::::::::::::::::::::::::::::::::::&quot;)

    val inicialForEach1 = System.currentTimeMillis()
    list.forEach {
        //println(it)
    }
    println(System.currentTimeMillis() - inicialForEach1)


}

println("\nIntRange")
println("ForLoop Time: " + measureNanoTime {
    for (i in 0 until 10000) { doSomething() }  // ForLoop Time: 467412. Mejor opción (para rangos).
})
println("ForEach Time: " + measureNanoTime {
    (0 until 10000).forEach { doSomething() }  // ForEach Time: 510866s.
})

println("\nList")
val listP = (1..10000).toList()

println("ForLoop Time: " + measureNanoTime {
    for (i in listP) { doSomething() }  // ForLoop Time: 786258
})
println("ForEach Time: " + measureNanoTime {
    listP.forEach { doSomething() }  // ForEach Time: 535152. Mejor opción (para cualquier colección).
})

fun main(args: Array<String>) {

    var addEmloy = true

    do {
        println("You name")
        var name = readLine()
        println("You salary")
        var salary = Integer.valueOf(readLine())
        println("Year")
        var year = Integer.valueOf(readLine())
        println("Vacation")
        var vacation = Integer.valueOf(readLine())

        var pago = salary * year
        var total = pago + (salary / 30 * vacation)

        println("$name su pago es $total")
        println("Desea agregar otro empleado (s/n)")

        var respuesta = readLine()!!.toString()
        if (respuesta == "n")
            addEmloy = false
    }
    while (addEmloy)

}

 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    println("\n*/*/*/*/*/*/*/*/*/*/*/*/Operadores lógicos For y For Each*/*/*/*/*/*/*/*/*/*/*/ *")
    println("Tener en Cuenta que el FOR es 10X más rápido que el FOR EACH")
    var daysOfWeek = listOf("Domingo", "Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sábado")

    println("Forma Tradicional (FOR)")
    for (day in daysOfWeek){

        println("El dia es: $day")

    }

    println("Indices en For (FOR)")
    for ((index, day) in daysOfWeek.withIndex()){
        println("El Índice es $index y el dia es: $day")

    }

    println("forma simplificada (FOREACH)")
    daysOfWeek.forEach{

        println(it) //variable de la iteración

    }```

fun main(args: ArrayList&lt;String&gt;){
  var daysOfWeek=listOf(&quot;Domingo&quot;,&quot;Lunes&quot;,&quot;Martes&quot;,&quot;Miercoles&quot;,&quot;Jueves&quot;,&quot;Viernes&quot;,&quot;Sabado&quot;)
    for((index,day) in daysOfWeek.withIndex())
        println(&quot;${index.plus(1)} :$day&quot;)
}

val list = listOf(&quot;Domingo&quot;,&quot;Lunes&quot;,&quot;Martes&quot;,&quot;Miercoles&quot;,&quot;Jueves&quot;,&quot;Viernes&quot;,&quot;Sabado&quot;)
 list.forEachIndexed { index, i -&gt; println(&quot;$i ------- $index&quot; ) }

      //ciclo for
    var daysOfWeek = listOf("Domingo","Lunes","Martes","Miercoles","Jueves","Viernes","Sabado")
    for(day in daysOfWeek){
        println(day)
    }
    //ciclo for con indice
    for((index,day) in daysOfWeek.withIndex()) {
        when (index) {
            in 1..5 -> println("entre semana $index :$day")
            else -> println("fin semana $index :$day")

        }
    }
    //ciclo forEach
    daysOfWeek.forEach{
        println(it)
    }```

Ciclos for y foreach en Kotlin

Bienvenida e introducción

Aprende sobre Kotlin con los cursos actualizados

¿Por qué debo aprender Kotlin?

Mi primer programa en Kotlin

Conceptos básicos

Variables vs. Objetos

Operadores en Kotlin

Otros Operadores en Kotlin

Tipos de variables: var, val y const

Ejercicio var val const

Programación Funcional: Funciones Puras e Inmutabilidad

Strings

Conversión de tipos de datos

Rangos

If y when en Kotlin

Bucles while y do while

Ciclos for y foreach en Kotlin

Break, Continue y Labels

Valores Nulos y Double Bang

Operador Elvis

Ejercicios con Null Safety y operador Elvis

Reto 1

Conceptos avanzados

¿Qué es un Array en Kotlin?

Métodos útiles en arreglos

Expresiones vs. Valores

Funciones en Kotlin

Funciones con parámetros por defecto

Lambdas en Kotlin

Ejemplo de Lambdas

Reto 2

Programación Orientada a Objetos

Clases

Ejercicio de clases

Modificadores de acceso

Getters y Setters

El Get() y Set() propio de Kotlin

Data class en Kotlin

Método Constructor

Herencia y polimorfismo

Aplicando herencia y polimorfismo

Clases abstractas

Interfaces

Reto 3

Programación Funcional

Funciones de orden superior

Una función como parámetro

Recursividad. List

Recursividad. Filter

Reto 4

Conclusiones

Bonus

Java Vs Kotlin