This is the part 6 of series Java to Kotlin - Learning Simplified. I hope you are learning something new from every part. This part is very simple and easy to grasp. Consider it a break in this series.

If you have not read part 5 (Constructors and Inheritance), please do here.

Index of this Part: If Expression, When Expression, Range, Range with Step, For In Loop, Labelled Block




If as an Expression


As we know almost every language has if-else conditional control flow. Java and Kotlin both are no exception. They both have if-else. Interestingly in Kotlin if-else can be used as expression as well. Here is snippet:

	// Kotlin

	val abc = if(condition) value_1 else value_2

	fun doSomething(){
		return if(condition) value_1 else value_2
	}

💡 Both of the ways shown above are not possible in Java.




When Expression


I am sure you are aware of switch statement in Java. Switch can be used when you have if-else ladder. Kotlin does not have switch keyword, It has when keyword offering same feature + more power at your disposal. Here is a snippet of code:

	// Kotlin
	val x = (Math.random() * 100).toInt()
	if(x == 10) { 

	} else if (x == 20) {

	} else if(x == 30) {

	} else if(x == 40) {

	} else {

	}

💡 As you saw above if-else ladder is not fun to read. Java has a switch-case offering, Here is Java solution:

	// Java
	switch(x){
		case 10:
		break;
		case 20:
		break;
		case 30:
		break;
		case 40:
		break;
		case 50:
		break;
		default:
		break;
	}

💡 This is surely better than if-else ladder but Java comes with its own overheads. There is a break after every case. If you do not add the break, next case will execute irrespective of the match. Honestly, its not nice. But kotlin played smart here and introduced when, Here is a snippet:

	// Kotlin
	when(x) {
	10 -> doSomething()
	20 -> {
			doSomething2()
		  }
	30 -> doThat()
	else -> {}
	}

💡 As you saw above when is equivalent to switch but we do not need break statement after a block. Only the matching block will execute otherwise else block will.

Power of When

In Java switch, we can combine two cases, lets say you want to execute two blocks. X is either 10 OR 20. In java you can write case 10 and case 20 without a break in between But in Kotlin all you need is a comma

	// Kotlin
	when(x) {
	10, 20 -> {}
	30, 40 -> {}
	}

What to do if you want to match more than 2 conditions

One answer is use multiple values with comma

	// Kotlin
	when(x) {
	10, 20, 30, 40 -> {}
	50, 60 -> {}
	}

Other solution is to use Range




🔥 Range ..


Kotlin offers a syntax .. whenever we need a range, could be range of numbers, chars etc. 1..10 means from 1 to 10 both inclusive. A..Z means all the capital alphabets. We can use range at multiple places, When block and for loop are two common use cases.

When with range

	// Kotlin
	when(x) {
	in 1..10 -> {}
	in 2..20 -> {}
	in 3..30 -> {}
	in 4..40 -> {}
	in 5..50 -> {}
	in 6..60 -> {}
	}

In the above code, if x is between 1 to 10 (both inclusive), the first block will execute.

We can use !in with range as well. It means not in range.

When with range

	// Kotlin
	when(x) {
	!in 1..10 -> {}
	in 2..20 -> {}
	}

!in 1..10 means not in 1 to 10, Any number not 1 to 10.

When with is

Do you remember is? it is used to check instance of in Kotlin. You can use it with when

	// Kotlin
	when(x){
		is String-> {}
		is Number-> {}
		is XYZ-> {}
	}

🔥 You can use variable declaration in when block. It is not allowed in Java

	// Java
	switch(final int x){}  ❌ not allowed
	// Kotlin
	when(val x = "Gaurav") { ✅ allowed
		"Gaurav" -> println(x.toLowerCase()) 
	}

I hope you are amazed with the power of when, if not it has more to offer. There are cases when we have conditions like < > or null check or something else. When can be used without a variable as well.

	// Java
	switch { ❌ not allowed

	}
	// Kotlin 🔥🔥

	when { ✅ allowed

		x > y -> {}

		4 < 5 -> {}

		obj == null -> {}

		else ->{}
	}

One more, I promise. when can be used as expression as well. This is amazing.

	// Kotlin

	fun doSomething():String{
		return when {
			x > y -> {}

			4 < 5 -> {}

			obj == null -> {}

			else ->
		}
	}

💡 else is mandatory in such cases and the last statement of the block is returned




🔥 Range .. with step


In last example of range we saw we can use 1..10 to express a range of 1 to 10. But what if we need all the even numbers from 1 to 100? That too is a range. There is a syntax for this as well. It is called step

0..100 step 2 is the range of all the even numbers till 100

There is nothing like that in Java




For Loop (foreach)


In java we have a foreach loop, there is a better alternative in Kotlin. Lets say we have an array of String name cities. Here is a snippet:

	// Java
	for(String city:cities) {}
	// Kotlin
	for(city:String in cities){}

The syntax is for in, we just saw above in syntax works very well with range as well. How about we combine for loop with range

	// Kotlin
	for(i in 1..10){}

The java equivalent is for i loop

	// Java
	for (int i=1; i<=10; i++){}

In my opinion, Kotlin variant is more readable. Wait, do you remember step with range? How about we add step in for loop?

	// Kotlin, loop with i = 1, 3, 5, 7.. (equivalent of += in java)

	for(i in 1..10 step 2){}

All of the step we saw are in increment fashion. What about decrement? In Java, we can easily do i=10; i>=0;i--, how about in Kotlin?

	// Kotlin
	for(i in 10 downTo 1 step 2){}

The above snippet will work with i = 10, 8, 6 ... Remember 10..1 will not work!!

💡 for-in can be used with any type which has iterator, It means it can be used with arrays, collections.




Labelled Block


This is one of the feature a very few developers use. Java and Kotlin both offer labelled blocks. The syntax is little different. Assume you are in nested loop and you want to break from the outer loop, Here is the snippet:

	// Java
	iloop:
	for (int i = 0; i < 10; i++) {
		jloop:
		for (int j = 0; j < 10; j++) {
			kloop:
        	for (int k = 0; k < 10; k++) {
				if (k == 3) {
				break jloop;
				}
				if (k == 4) {
				break iloop;
				}
			}
		}
	}
	// Kotlin
	iloop@
    for (i in 1..10) {
        jloop@
        for (j in 1..10) {
            kloop@
            for (k in 1..10) {
                if (k == 3) {
                    break@jloop
                }
                if (k == 4) {
                    break@iloop
                }
            }
        }
    }

💡 Kotlin has the syntax name@ for labelled blocks and while using you have to use @name


Summary


We saw power of kotlin in tiny offerings like If as an expression, and When block which is powerful alternative to switch. When can be used when you have a direct comparison like switch OR when you have multiple if elses. It can also be used as an Expression.

Then we saw range the syntax .. can be used in places like comparison inside when OR for loop. Decrement range can be calculated with downTo syntax. Range with step can be used when the increment OR decrement step is other than 1.

For in loop is similar to Java for each loop and can be combined with range. It can be used with any type which has iterator like array and collection.

Finally we saw Labelled block is same like Java with different sytanx label@.

🔥 Hope you learned something, This part was very easy to grasp. Next part is also not difficult. Here is part 7

Subscribe to newsletter and keep learning good stuff

Email

👉 If you like article, click on ♥️ recommend and share on social 👥 media.
👉 Feel free to comment 💬
👉 Follow me 👀 for the more interesting articles. Twitter Medium
👉 Subscribe to newsletter and keep learning