Scala Map (mapeamento)

def ++(xs: Map[(A, B)]): Map[A, B]

Retornar um novo Map, composto por novos Map xs

def -(elem1: A, elem2: A, elems: A*): Map[A, B]

Retornar um novo Map, removendo a chave elem1, elem2 ou outros elems.

def --(xs: GTO[A]): Map[A, B]

Retornar um novo Map, removendo o objeto xs correspondente 　key

def get(key: A): Option[B]

Retornar o valor da chave especificada

def iterator: Iterator[(A, B)]

Criar um novo iterador e output key/value par

def addString(b: StringBuilder): StringBuilder

Adicionar todos os elementos da Map ao StringBuilder, pode adicionar delimitador

def addString(b: StringBuilder, sep: String): StringBuilder

Adicionar todos os elementos da Map ao StringBuilder, pode adicionar delimitador

def apply(key: A): B

Retornar o valor da chave especificada, se não existir, retornar o método padrão da Map

def clear(): Unit

Limpar Map

def clone(): Map[A, B]

Copiar de uma Map para outra Map

def contains(key: A): Boolean

Se a Map existir com a chave especificada, retorna true, caso contrário, retorna false.

def copyToArray(xs: Array[(A, B)]): Unit

Copia o conjunto para um array

def count(p: ((A, B)) => Boolean): Int

Calcula o número de elementos que atendem à condição especificada no conjunto

def default(key: A): B

Define o valor padrão do Map, que é retornado quando a chave não existe

def drop(n: Int): Map[A, B]

Retorna um novo conjunto descartando os primeiros 'n' elementos

def dropRight(n: Int): Map[A, B]

Retorna um novo conjunto descartando os últimos 'n' elementos

def dropWhile(p: ((A, B)) => Boolean): Map[A, B]

Descarta elementos à esquerda, até que a condição 'p' não seja mais verdadeira

def empty: Map[A, B]

Retorna um Map vazio do mesmo tipo

def equals(that: Any): Boolean

Se dois Map forem iguais (key/Se os valores 'value' forem iguais, retorna true, caso contrário, retorna false

def exists(p: ((A, B)) => Boolean): Boolean

Determina se existe um elemento que atenda à condição especificada no conjunto

def filter(p: ((A, B))=> Boolean): Map[A, B]

Retorna todos os conjuntos que atendem à condição especificada

def filterKeys(p: (A) => Boolean): Map[A, B]

Retorna um Map imutável que atende à condição especificada

def find(p: ((A, B)) => Boolean): Option[(A, B)]

Encontra o primeiro elemento que satisfez a condição especificada no conjunto

def foreach(f: ((A, B)) => Unit): Unit

Aplica a função em todos os elementos do conjunto

def init: Map[A, B]

Retorna todos os elementos, exceto o último

def isEmpty: Boolean

Verifica se o Map está vazio

def keys: Iterable[A]

Retorna todas as chaves/p>

def last: (A, B)

Retorna o último elemento

def max: (A, B)

Encontra o elemento maior

def min: (A, B)

Encontra o elemento mais pequeno

def mkString: String

Exibe todos os elementos do conjunto como strings

def product: (A, B)

Retorna o produto dos elementos numéricos do conjunto.

def remove(key: A): Option[B]

Remove a chave especificada

def retain(p: (A, B) => Boolean): Map.this.type

Se atender ao critério, retorna true

def size: Int

Retorna o número de elementos do Map

def sum: (A, B)

Retorna a soma de todos os elementos numéricos da coleção

def tail: Map[A, B]

Retorna todos os elementos de uma coleção exceto o primeiro

def take(n: Int): Map[A, B]

Retorna os n primeiros elementos

def takeRight(n: Int): Map[A, B]

Retorna os n últimos elementos

def takeWhile(p: ((A, B)) => Boolean): Map[A, B]

Retorna os elementos que atendem ao critério especificado

def toArray: Array[(A, B)]

Conversão de conjunto para array

def toBuffer[B >: A]: Buffer[B]

Retorna um buffer que contém todos os elementos do mapa

def toList: List[A]

Retorna uma lista que contém todos os elementos do mapa

def toSeq: Seq[A]

Retorna um seq que contém todos os elementos do mapa

def toSet: Set[A]

Retorna um conjunto que contém todos os elementos do mapa

def toString(): String

Retorna um objeto de string