Is there a way to create objects array without fil...

# getting-started

[juh juh]

Is there a way to create objects array without filling and manually fill it afterwards?
Like, in my case I have something like this, but it's a bit ugly, and it does unnecessary filling array with null

val tempLines = Array<IntArray?>(width + height) { null } as Array<IntArray>
            for (x in 0 until width) {
                tempLines[x] = IntArray(height) { y -> x + y * width }
            }
            for (y in 0 until height) {
                tempLines[y + width] = IntArray(width) { x -> x + y * width }
            }

Creating two arrays and concatenating them via + is not an option, because performance is very critical

[Klitos Kyriacou]

A slightly shorter version of your first line is:

val tempLines = arrayOfNulls<IntArray>(width + height) as Array<IntArray>

But why not initialize in one go?

val tempLines = Array(width + height) {
    if (it < width)
        IntArray(height) { y -> it + y * width }
    else
        IntArray(width) { x -> x + it * width }
}

[ephemient]

there is also https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/require-no-nulls.html

[juh juh]

I don't really like that if(it < width) check called on every loop step, tho maybe performance hit is negligible enough for me to use it

[ephemient]

the initial "filling the array with nulls" always happens automatically on JVM; the Array pseudo-constructor hides that from you

[juh juh]

Hmm, I will check out requireNotNull but I doubt it doesn't have performance implications

[juh juh]

@ephemient looking at decompilled bytecode, Array(length){null} actually have a dedicated loop upon creation, setting every element to null

[juh juh]

arrayOfNulls doesn't have this issue as far as I see

[ephemient]

it's not visible in the bytecode

[ephemient]

the JVM will never hand you an uninitialized array - it's always pre-filled

[juh juh]

image.png,image.png

[juh juh]

Even looking at bytecode, fun1 have significantly more operations than fun2

[ephemient]

that's not what I'm talking about

[juh juh]

I know that I get array of nulls in both cases, but in fun1 there is an extra loop, writing `null`s into array of `null`s

[ephemient]

what I mean is that the Array constructor is effectively

fun <T> Array(size: Int, init: (Int) -> T) =
    arrayOfNulls<T>(size).apply {
        for (i in 0 until size) {
            set(i, init(i))
        }
    } as Array<T>

although it's hard-wired in the compiler

[juh juh]

Ah, got it

[ephemient]

if you really want performance, I suspect it would be better not to use 2-D arrays. use a flat IntArray and manage your own indexing

[juh juh]

I already do that for main map itself, but I can't really do that for lines, because they can be varying length. Even in this very consistent example, we have vertical and horizontal lines, which have different lengths

[juh juh]

Aka, on different fields lines will be generated in different ways, and I can make no assumptions about them

[juh juh]

Thank you for help!

[ephemient]

it looks like you have a width*height array + a height*width array concatenated together

[ephemient]

that is totally doable in a one or two flat arrays