kotlin, which one is better, using "is" or "as?", - kotlin

Question

two functions test1 and test2, one uses "is" to check type, and one use "as?", seems test2 with "as?" has less code, but is it really better than the one uses "is" to do check?
Is there a comparison for using "is" vs. "as?", what is suggestion for general use of these two?
class Message(val int: Int, val msg:String)
class Test {
fun test1(objList: List<Any?>) {
for (i in objList.size - 1 downTo 0) {
val item = objList.get(i)
if (item is Message) {
println(item)
}
}
}
fun test2(objList: List<Any?>) {
for (i in objList.size - 1 downTo 0) {
(objList.get(i) as? Message)?.let {item ->
println(item)
}
}
}
}

Answer 1

So if you look at the JVM bytecode of both:
// JVM bytecode of test1
L5
LINENUMBER 8 L5
ALOAD 3
INSTANCEOF com/example/artifact/Message
IFEQ L6
// JVM bytecode of test2
L4
LINENUMBER 16 L4
ALOAD 0
ILOAD 1
INVOKEINTERFACE java/util/List.get (I)Ljava/lang/Object; (itf)
DUP
INSTANCEOF com/example/artifact/Message
IFNE L5
POP
ACONST_NULL
L5
CHECKCAST com/example/artifact/Message
DUP
IFNULL L6
ASTORE 3
You can clearly see that the test1 does check for the type only and it smart casts the result, while the test2 however first checks if the instance is of that type and then returns null or "casts" explicitly it to that type.
So, through this observation I'll suggest you to use the is operator as it is more optimized for these tasks. If you don't like using curly braces then you can omit them like python, or put the println on the same line as you're doing if conditions.
This is more optimized code if you'd like:
fun test1(objList: List<Any>) {
for (item in objList.asReversed()) {
if (item is Message) println(item)
}
}
fun test2(objList: List<Any>) {
for (item in objList.asReversed()) {
(item as? Message)?.let { println(it) }
}
}

Answer 2

The as? version may have one less line of code, but does it really have less code overall? You may have gotten rid of:
val item = objList.get(i)
But you replaced it with:
(objList.get(i) as? Message)?.let {item ->
In this case, I'd argue that the as? version requires ever so slightly more time to comprehend than the is version, which is more straightforward. I also doubt there's a significant difference in performance between the two approaches. In general, always prefer the more readable code over the more performant code unless you've profiled an actual performance problem in your application. Whether or not there's a performance problem is highly dependent on the context of your application. And remember, premature optimization is the root of all evil.
If you really want less code then consider using the following:
fun test(objList: List<Any>) = objList.asReversed().forEach {
if (it is Message) println(it)
}
This makes use of:
Single-expression functions
List.asReversed (returns a reversed view of the original list)
Iterable.forEach
it: implicit name of a single parameter (in lambda expressions)

Answer 3

is is type checking. as is type casting.
the different is
is return boolean, true or false
as return that type
you use is if you want the answer only yes or no
example
if (user is Login) you just want the answer yes or no right?
and then you do something else
you use as when you want to try to cast to that type
example
(user as? Admin).let{print(it.name.toString())}
this one you want to check if this user is Admin or not
if yes you want to use that user value to print something like name
so for condition Use is
for casting Use as
fun test(objList: List<Any>) = objList.asReversed().forEach {
when(it){ is Message -> println(it)}
}