Collections Scala - Carte

La carte Scala est une collection de paires clé / valeur. Toute valeur peut être récupérée en fonction de sa clé. Les clés sont uniques dans la carte, mais les valeurs n'ont pas besoin d'être uniques. Les cartes sont également appelées tables de hachage. Il existe deux types de cartes, laimmutable et le mutable. La différence entre les objets mutables et immuables est que lorsqu'un objet est immuable, l'objet lui-même ne peut pas être modifié.

Par défaut, Scala utilise la carte immuable. Si vous souhaitez utiliser la carte mutable, vous devrez importerscala.collection.mutable.Mapclasse explicitement. Si vous souhaitez utiliser à la fois des cartes mutables et immuables dans le même, vous pouvez continuer à faire référence à la carte immuable commeMap mais vous pouvez faire référence à l'ensemble mutable comme mutable.Map.

Voici les exemples d'instructions pour déclarer des cartes immuables -

// Empty hash table whose keys are strings and values are integers:
var A:Map[Char,Int] = Map()

// A map with keys and values.
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")

Lors de la définition d'une carte vide, l'annotation de type est nécessaire car le système doit affecter un type concret à la variable. Si nous voulons ajouter une paire clé-valeur à une carte, nous pouvons utiliser l'opérateur + comme suit.

A + = ('I' -> 1)
A + = ('J' -> 5)
A + = ('K' -> 10)
A + = ('L' -> 100)

Opérations de base sur MAP

Toutes les opérations sur les cartes peuvent être exprimées selon les trois méthodes suivantes.

Sr. Non	Méthodes et description
1	keys Cette méthode retourne un itérable contenant chaque clé de la carte.
2	values Cette méthode retourne un itérable contenant chaque valeur de la carte.
3	isEmpty Cette méthode renvoie true si la carte est vide, sinon false.

Essayez l'exemple de programme suivant montrant l'utilisation des méthodes Map.

Exemple

object Demo {
   def main(args: Array[String]) {
      val colors = Map(
         "red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F"
      )
      val nums: Map[Int, Int] = Map()
      println( "Keys in colors : " + colors.keys )
      println( "Values in colors : " + colors.values )
      println( "Check if colors is empty : " + colors.isEmpty )
      println( "Check if nums is empty : " + nums.isEmpty )
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

Keys in colors : Set(red, azure, peru)
Values in colors : MapLike(#FF0000, #F0FFFF, #CD853F)
Check if colors is empty : false
Check if nums is empty : true

Concaténation de cartes

Vous pouvez utiliser soit ++ opérateur ou Map.++() méthode pour concaténer deux ou plusieurs cartes, mais lors de l'ajout de cartes, elle supprimera les clés en double.

Essayez l'exemple de programme suivant pour concaténer deux cartes.

Exemple

object Demo {
   def main(args: Array[String]) {
      val colors1 = Map(
         "red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F"
      )
      val colors2 = Map(
         "blue" -> "#0033FF", "yellow" -> "#FFFF00", "red" -> "#FF0000"
      )
      // use two or more Maps with ++ as operator
      var colors = colors1 ++ colors2
      println( "colors1 ++ colors2 : " + colors )
      // use two maps with ++ as method
      colors = colors1.++(colors2)
      println( "colors1.++(colors2)) : " + colors )
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

colors1 ++ colors2 : Map(blue -> #0033FF, azure -> #F0FFFF, 
   peru -> #CD853F, yellow -> #FFFF00, red -> #FF0000)

colors1.++(colors2)) : Map(blue -> #0033FF, azure -> #F0FFFF, 
   peru -> #CD853F, yellow -> #FFFF00, red -> #FF0000)

Imprimer des clés et des valeurs à partir d'une carte

Vous pouvez parcourir les clés et les valeurs d'une carte en utilisant la boucle "foreach". Ici, nous avons utilisé la méthodeforeachassocié à l'itérateur pour parcourir les touches. Voici l'exemple de programme.

Exemple

object Demo {
   def main(args: Array[String]) {
      val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF","peru" -> "#CD853F")

      colors.keys.foreach{
         i =>  
         print( "Key = " + i )
         println(" Value = " + colors(i) )
      }
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

Key = red Value = #FF0000
Key = azure Value = #F0FFFF
Key = peru Value = #CD853F

Rechercher une clé sur la carte

Vous pouvez utiliser soit Map.containsméthode pour tester si une clé donnée existe ou non dans la carte. Essayez le programme exemple suivant pour vérifier les touches.

Exemple

object Demo {
   def main(args: Array[String]) {
      val colors = Map(
         "red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F"
      )
      if( colors.contains( "red" )) {
         println("Red key exists with value :"  + colors("red"))
      } else {
         println("Red key does not exist")
      }
      if( colors.contains( "maroon" )) {
         println("Maroon key exists with value :"  + colors("maroon"))
      } else {
         println("Maroon key does not exist")
      }
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

Red key exists with value :#FF0000
Maroon key does not exist