À l'aide de la fonction rechercher pour les cartes en scala

Je suis en train d'essayer de trouver une clé dans une Carte, donné une valeur. Je suis l'aide de la "trouver" de la fonction par pas en mesure de comprendre le droit de prédicat:

val colors = Map(1 -> "red", 2 -> "blue")
def keyForValue(map: Map[Int, String], value: String) = {
    val bool = map.find{map.foreach{map.values(i) == value}}
        bool.key
  }

Comment puis-je effectuer une itération sur la carte et de trouver la clé quand je sais la valeur?

OriginalL'auteur Core_Dumped | 2013-10-24

map scala

12

Vous utilisez le même type de prédicat avec un List, mais gardez à l'esprit que vous êtes de les évaluer sur (key,value) paires, au lieu de simplement les valeurs (et d'obtenir une paire retour!).

Exemple Simple:
```
val default = (-1,"")
val value = "red"
colors.find(_._2==value).getOrElse(default)._1
```
Il renvoie à une Certaine(1, "rouge"). Puis-je extraire la clé?
Je suppose que de l'accepter, que vous avez probablement déjà compris, mais juste au cas où: si vous exécutez le code tel qu'il est réellement dans la réponse, vous obtiendrez la clé. C'est ce que .getOrElse(default)._1 est pour. Il extrait la valeur de la Option vous obtenez à partir de find, par défaut, et avec _1 vous obtenez le premier élément de la paire, qui se trouve être la clé dans le cas de cartes.

OriginalL'auteur mikołak

La signature de find dans Map est find(p: ((A, B)) ⇒ Boolean): Option[(A, B)]. Ainsi, le prédicat prend un Tuple2 et doit retourner une Boolean. Remarque j'ai changé value à un Int depuis la clé dans colors est aussi un Int.

scala> def keyForValue(map: Map[Int, String], value: Int) = {
     | colors.find({case (a,b) => a  == value})
     | }
keyForValue: (map: Map[Int,String], value: Int)Option[(Int, String)]

Test:

scala> keyForValue(colors, 1)
res0: Option[(Int, String)] = Some((1,red))

Vous pouvez également utiliser get:

scala> colors.get(1)
res1: Option[String] = Some(red)

OriginalL'auteur Brian

0

Vous pouvez toujours aller avec la solution abstraite et échanger les clés de leurs valeurs, de le stocker dans une nouvelle carte, et ensuite, la recherche de la nouvelle carte:
```
val colors = Map(1 -> "red", 2 -> "blue")
def keyForValue(map: Map[Int, String], value: String) = {
  val revMap = map map {_.swap}
  val key = revMap(value)
  key
}
```
La troisième ligne de swaps sur les touches avec leurs valeurs, et les stocke dans revMap. (map map signifie que le nom de la carte, dans ce cas, le paramètre de la carte, puis le mot de la carte, puis {_.swap} à fait permuter les touches avec leurs valeurs.

OriginalL'auteur kungfushark

Je voudrais éviter de passer la carte à la méthode find, et plutôt ne laisser passer que la carte est clés à la méthode find.

Cela évite de traiter avec une Option[Int,String] -- au lieu de cela, il est Option[Int].

//sample data
val colors = Map(1 -> "red", 2 -> "blue", 3 -> "yellow")

//function you need
def keyForValue(theMap: Map[Int, String], theValue: String): Int = {

    val someKey = theMap.keys.find( k => theMap(k) == theValue )
    someKey match {
        case Some(key) => {
            println(s"the map contains ${key} -> ${theValue}")
            return key
        }
        case None => {
            println(s"a key was not found for ${theValue}")
            return -1
        }
    }
}

Cela donne:

scala> val result = keyForValue( colors, "blue" )
the map contains 2 -> blue
result: Int = 2

scala>

OriginalL'auteur warrens

Vous devez vous connecter pour publier un commentaire.