En scala, comment puis-je trouver la taille d'un élément de tableau

Scala débutant, Avoir un tableau où un élément est un tableau:

val aaa = Array("a", "b", Array(1, 2, 3), "c")

Cela fonctionne:

In []: aaa(2)
Out[]: Array(1, 2, 3)

Cela fonctionne

In []: Array(1, 2, 3).size
Out[]:3

Ce n'est pas:

In []: aaa(2).size
Out[]:
Name: Compile Error
Message: <console>:15: error: value size is not a member of                     
java.io.Serializable
          aaa(2).size
                 ^

Ce que je fais mal?
Thnaks

Trouver le type de aaa variable
Comment dois-je faire?
Il semble être un Tableau
Ce n'est pas une bonne idée d'avoir un tableau avec plusieurs types, comme dans votre exemple. Pourquoi avez-vous envie de faire ?
Le type de aaa est Array[java.io.Serializable] Donc, quand vous ne aaa(2) vous obtenez un élément de type java.io.Serializable qui n'a pas une méthode à la taille définie.

OriginalL'auteur Ezer K | 2016-06-13

2

Lorsque vous créez un tableau à l'aide de la suite littérale
```
val aaa = Array("a", "b", Array(1, 2, 3), "c")
```
Puisque le type des éléments sont différents, le tableau aaa type est créé avec java.io.Serializable
```
aaa: Array[java.io.Serializable] = Array(a, b, Array(1, 2, 3), c)
```
Ainsi, lorsque vous renvoyer le 2ème élément, le type de la référence sera de Serializable et il n'y a pas de taille de la propriété. Nous avons donc besoin de transtypage explicite/convertir le 2ème élément de Tableau à l'aide de asInstanceOf. Comme indiqué ci-dessous
```
 if (aaa(2).isInstanceOf[Array[Int]]) 
       aaa(2).asInstanceOf[Array[Int]].size
```
Éviter de décocher jette. C'est dangereux et "odeur de code".

OriginalL'auteur rajuGT
2

Type le plus commun pour votre déclaration est sérialisable
```
val aaa = Array("a", "b", Array(1, 2, 3), "c")
Array[java.io.Serializable] 
```
Si vous voulez l'utiliser avec la taille, vous pouvez définir explicitement:
```
val aaa: Array[Seq[Any]] = Array("a", "b", Array(1, 2, 3), "c")
```
toutes les Chaînes doivent être convertis à des Séquences de Caractères dans ce cas.

C'est bien, car il ne nécessite pas de code conditionnel après le val est réglé.

OriginalL'auteur mavarazy
1

Comme mentionné dans les commentaires, ce n'est pas une bonne idée de mélanger les tableaux et les non-tableaux (et, en général, des éléments de types différents) dans un tableau. Parfois, il y a des cas particuliers, lorsque vous ne pouvez pas l'obtenir autour de les avoir à le faire, mais en règle générale, les tableaux (et d'autres scala conteneurs) sont destinés à tenir homogènes.

Donc, je vous recommande de commencer avec la division de votre tableau en deux:
```
val (arrays, nonArrays) =  
  Array("a", "b", Array(1, 2, 3), "c").partition { 
     case a: Array[_] => true
     case _ => false
  }
```
Maintenant, vous pouvez facilement déterminer les longueurs de tous vos tableaux:
```
  arrays.foreach { println(_.size) }
```
Si vous voulait conserver la position d'origine de l'information, vous pouvez compresser le tableau d'origine avec les index de la première:
```
 val (arrays, nonArrays) = Array("a", "b", Array(1, 2, 3), "c")
   .zipWithIndex
   .partition {
      case (a: Array[_], _) => true
      case _ => false
   }

 arrays.foreach { 
   case (array, index) => 
     prinlnt(s"Array length at index $index is ${array.size}")
 }
```
arrays.foreach { println(_.size) } ligne ne fonctionne pas. Parce que _ est toujours référence au type de java.io.Serializable et size n'est pas un membre de Serializable type. Pour info après l'exécution du premier bloc arrays reportez-vous à arrays:Array[java.io.Serializable] = Array(Array(1, 2, 3)).
J'ai essayé et ça n'a pas l'air de fonctionner, encore Serializable 🙁

OriginalL'auteur Dima

Vous devez vous connecter pour publier un commentaire.