web-dev-qa-db-fra.com

Tableau 2D à Kotlin

Comment fabrique-t-on un tableau 2D Int à Kotlin? J'essaie de convertir ce code en Kotlin:

    int[][] states = new int[][] {
        new int[]{-Android.R.attr.state_pressed}, // not pressed
        new int[] { Android.R.attr.state_pressed}  // pressed
    };
    int[] colors = new int[] {
        foregroundColor,
        accentColor,
        accentColor
    };
    ColorStateList myList = new ColorStateList(states, colors);

Voici une tentative que j'ai tentée: le premier tableau 2D ne fonctionnait pas, mais le tableau 1D fonctionnait correctement:

    //This doesn't work:
    var states: IntArray = intArrayOf(
        intArrayOf(-Android.R.attr.state_pressed), // not pressed
        intArrayOf(Android.R.attr.state_pressed)  // pressed
    );
    //This array works:
    var colors: IntArray = intArrayOf(
        foregroundColor,
        accentColor,
        accentColor
    );
    val myList: ColorStateList = ColorStateList(states, colors);
arrayskotlin
19
Rock Lee

Vous essayez de placer vos IntArrays dans un autre tableau pour le rendre en deux dimensions . Le type de ce tableau ne peut pas être intArray, raison pour laquelle cela échoue . Enveloppez vos tableaux initiaux avec arrayOf au lieu de intArrayOf.

val even: IntArray = intArrayOf(2, 4, 6)
val odd: IntArray = intArrayOf(1, 3, 5)

val lala: Array<IntArray> = arrayOf(even, odd)
23
Tim

Vous pouvez utiliser cette ligne de code pour un tableau Integer. 

val array = Array(row, {IntArray(column)})

Cette ligne de code est assez simple et fonctionne comme un tableau 1D et peut également être accessible comme un tableau Java 2D.

23
HM Nayem

Il semble que vous tentiez de créer une ColorStateList dans Kotlin. Le code est un peu brouillon, je vais essayer de le garder lisible:

val resolvedColor = Color.rgb(214,0,0)
val states = arrayOf(
    intArrayOf(-Android.R.attr.state_pressed),
    intArrayOf(Android.R.attr.state_pressed)
)

val csl = ColorStateList(
    states,
    intArrayOf(resolvedColor, Color.WHITE)
)
1
voghDev

Réponse courte:

// A 6x5 array of Int, all set to 0.
var m = Array(6) {Array(5) {0} }

Voici un autre exemple avec plus de détails sur ce qui se passe:

// a 6x5 Int array initialise all to 0
var m = Array(6, {i -> Array(5, {j -> 0})})

Le premier paramètre est la taille, la seconde méthode lambda est destinée à l'initialisation.

0
A-Sharabiani

Vous pouvez utiliser un simple tableau 1D (linéaire) à cette fin. Par exemple, voici ma classe pour un tableau rectangle de valeurs Double:

/**
 * Rect array of Double values
 */
class DoubleRectArray(private val rows: Int, private val cols: Int) {
    private val innerArray: DoubleArray

    init {
        if(rows < 1) {
            throw IllegalArgumentException("Rows value is invalid. It must be greater than 0")
        }

        if(cols < 1) {
            throw IllegalArgumentException("Cols value is invalid. It must be greater than 0")
        }

        innerArray = DoubleArray(rows*cols)
    }

    /**
     *
     */
    fun get(row: Int, col: Int): Double {
        checkRowAndCol(row, col)
        return innerArray[row*cols + col]
    }

    /**
     *
     */
    fun set(row: Int, col: Int, value: Double) {
        checkRowAndCol(row, col)
        innerArray[row*cols + col] = value
    }

    /**
     *
     */
    private fun checkRowAndCol(row: Int, col: Int) {
        if(row !in 0 until rows) {
            throw ArrayIndexOutOfBoundsException("Row value is invalid. It must be in a 0..${rows-1} interval (inclusive)")
        }

        if(col !in 0 until cols) {
            throw ArrayIndexOutOfBoundsException("Col value is invalid. It must be in a 0..${cols-1} interval (inclusive)")
        }
    }
}
0
Alex Shevelev

1. Appels arrayOf imbriqués

Vous pouvez imbriquer des appels de arrayOf, par exemple pour créer un tableau de IntArray, procédez comme suit:

val first: Array<IntArray> = arrayOf(
    intArrayOf(2, 4, 6),
    intArrayOf(1, 3, 5)
)

Notez que la IntArray elle-même ne prend comme arguments que des arguments de type Int; vous ne pouvez donc pas avoir un IntArray<IntArray> qui n'a évidemment aucun sens.

2. Utilisez Array::constructor(size: Int, init: (Int) -> T) pour la logique répétée

Si vous voulez créer vos tableaux internes avec un comportement logique basé sur l'index, vous pouvez utiliser le constructeur Array en prenant une taille et un bloc init:

val second: Array<IntArray> = Array(3) {
    intArrayOf(it * 1, it * 2, it * 3, it * 4)
} 
//[[0, 0, 0, 0], [1, 2, 3, 4], [2, 4, 6, 8]]
0
s1m0nw1