English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
Scala Set (conjunto) é um conjunto de objetos sem repetições, onde todos os elementos são únicos.
Os conjuntos Scala são divididos em conjuntos mutáveis e imutáveis.
Pelo padrão, o Scala usa conjuntos imutáveis. Se você quiser usar conjuntos mutáveis, você deve referenciar scala.collection.mutable.Set Pacote.
O padrão é referenciar scala.collection.immutable.Set, exemplos de conjuntos imutáveis são os seguintes:
val set = Set(1,2,3) println(set.getClass.getName) // println(set.exists(_ %) 2 == 0)) //true println(set.drop(1) //Set(2,3)
Se precisar usar conjuntos mutáveis, você deve importar scala.collection.mutable.Set:
import scala.collection.mutable.Set // Você pode importar conjuntos mutáveis em qualquer lugar val mutableSet = Set(1,2,3) println(mutableSet.getClass.getName) // scala.collection.mutable.HashSet mutableSet.add(4) mutableSet.remove(1) mutableSet += 5 mutableSet -= 2 println(mutableSet) // Set(5, 3, 4) val another = mutableSet.toSet println(another.getClass.getName) // scala.collection.immutable.Set
Atenção:Embora os Sets mutáveis e imutáveis tenham operações de adição ou exclusão de elementos, há uma grande diferença. A operação em um Set imutável gera um novo set, e o set original não é alterado, o que é semelhante a uma Lista. Enquanto isso, a operação em um Set mutável altera o próprio Set, semelhante a um ListBuffer.
Conjunto Scala tem três operações básicas:
head retorna o primeiro elemento do conjunto
tail retorna um conjunto que contém todos os elementos exceto o primeiro
isEmpty retorna true quando o conjunto está vazio
Qualquer operação em conjuntos Scala pode ser expressa usando essas três operações básicas. Exemplo a seguir:
object Test {
def main(args: Array[String]) {
val site = Conjunto("w3codebox", "Google", "Baidu")
val nums: Conjunto[Int] = Conjunto()
println( "O primeiro site é : " + site.head )
println( "O último site é : " + site.tail )
println( "Verificar se a lista site está vazia : " + site.isEmpty )
println( "Verificar se nums está vazio : " + nums.isEmpty )
}
}executar o código acima, o resultado de saída será:
$ vim Test.scala $ scala Test.scala O primeiro site é : w3codebox O último site é : Conjunto(Google, Baidu) Verificar se a lista site está vazia : false Verificar se nums está vazio : true
você pode usar ++ Operador lógico ou Conjunto.++()) Método para conectar dois conjuntos. Se os elementos forem repetidos, eles serão removidos. Exemplo a seguir:
object Test {
def main(args: Array[String]) {
val site1 = Conjunto("w3codebox", "Google", "Baidu")
val site2 = Conjunto("Faceboook", "Taobao")
// ++ Como operador de uso
var site = site1 ++ site2
println( "site1 ++ site2 : " + site )
// ++ Como método de uso
site = site1.++(site2)
println( "site1.++(site2) : " + site )
}
}executar o código acima, o resultado de saída será:
$ vim Test.scala $ scala Test.scala site1 ++ site2 : Conjunto(Faceboook, Taobao, Google, Baidu, w3codebox) site1.++(site2) : Conjunto(Faceboook, Taobao, Google, Baidu, w3codebox)
você pode usar Conjunto.min Método para encontrar o elemento mínimo no conjunto, usando Conjunto.max Método para encontrar o elemento máximo no conjunto. Exemplo a seguir:
object Test {
def main(args: Array[String]) {
val num = Conjunto(5,6,9,20,30,45)
// Procurar o elemento máximo e mínimo no conjunto
println( "Conjunto(5,6,9,20,30,45) O elemento mínimo do conjunto é : " + num.min )
println( "Conjunto(5,6,9,20,30,45) O elemento máximo do conjunto é : " + num.max )
}
}executar o código acima, o resultado de saída será:
$ vim Test.scala $ scala Test.scala Set(5,6,9,20,30,45) o elemento mínimo do conjunto é : 5 Set(5,6,9,20,30,45) o elemento máximo do conjunto é : 45
você pode usar Set.& método ou Set.intersecção métodos para visualizar os elementos de intersecção de dois conjuntos. O exemplo é o seguinte:
object Test {
def main(args: Array[String]) {
val num1 = Set(5,6,9,20,30,45)
val num2 = Set(50,60,9,20,35,55)
// intersecção
println( "num1.& (num2) : " + num1.& (num2) )
println( "num1.intersecção(num2) : " + num1.intersecção(num2) )
}
}executar o código acima, o resultado de saída será:
$ vim Test.scala $ scala Test.scala num1.& (num2) : Set(20, 9) num1.intersecção(num2) : Set(20, 9)
a tabela a seguir lista os métodos comuns do Scala Set:
| número de série | método e descrição |
|---|---|
| 1 | def +(elem: A): Set[A] adicionar um novo elemento ao conjunto, x, e criar um novo conjunto, a menos que o elemento já exista |
| 2 | def -(elem: A): Set[A] remover um elemento do conjunto e criar um novo conjunto |
| 3 | def contém(elem: A): Boolean se o elemento existir no conjunto, retorna true, caso contrário, retorna false. |
| 4 | def &(aquele: Set[A]): Set[A] retornar a interseção de dois conjuntos |
| 5 | def &~(aquele: Set[A]): Set[A] retornar a diferença entre dois conjuntos |
| 6 | def +(elem1: A, elem2: A, elems: A*: Set[A] criar um novo conjunto imutável adicionando os elementos do conjunto especificado |
| 7 | def ++(elems: A): Set[A] juntar dois conjuntos |
| 8 | def -(elem1: A, elem2: A, elems: A*: Set[A] criar um novo conjunto imutável removendo os elementos do conjunto especificado |
| 9 | def adicionarString(b: StringBuilder): StringBuilder adicionar todos os elementos de um conjunto imutável ao buffer de string |
| 10 | def adicionarString(b: StringBuilder, sep: String): StringBuilder adicionar todos os elementos de um conjunto imutável ao buffer de string, usando um separador específico |
| 11 | def aplicar(elem: A) detetar se um conjunto contém um elemento específico |
| 12 | def contar(p: (A) => Boolean): Int calcular o número de elementos de um conjunto que satisfazem uma condição específica |
| 13 | def copiarParaArray(xs: Array[A], início: Int, comprimento: Int): Unit Copia elementos da coleção imutável para um array |
| 14 | def diff(that: Set[A]): Set[A] Compara a diferença entre duas coleções |
| 15 | def drop(n: Int): Set[A] Retorna uma nova coleção descartando os primeiros n elementos |
| 16 | def dropRight(n: Int): Set[A] Retorna uma nova coleção descartando os últimos n elementos |
| 17 | def dropWhile(p: (A) => Boolean): Set[A] Descarta elementos da esquerda para a direita até que a condição p não seja mais verdadeira |
| 18 | def equals(that: Any): Boolean O método equals pode ser usado para qualquer sequência. Usado para comparar se as séries são iguais. |
| 19 | def exists(p: (A) => Boolean): Boolean Verifica se existe um elemento que atenda à condição específica na coleção imutável. |
| 20 | def filter(p: (A) => Boolean): Set[A] Emita todos os elementos imutáveis que atendem à condição específica. |
| 21 | def find(p: (A) => Boolean): Option[A] Encontra o primeiro elemento que atende à condição específica na coleção imutável |
| 22 | def forall(p: (A) => Boolean): Boolean Verifica se a condição específica se aplica a todos os elementos da coleção |
| 23 | def foreach(f: (A) => Unit): Unit Aplica a função a todos os elementos da coleção imutável |
| 24 | def head: A Obtém o primeiro elemento da coleção imutável |
| 25 | def init: Set[A] Retorna todos os elementos, exceto o último |
| 26 | def intersect(that: Set[A]): Set[A] Calcula a interseção de duas coleções |
| 27 | def isEmpty: Boolean Verifica se a coleção está vazia |
| 28 | def iterator: Iterador[A] Cria um novo iterador para iterar os elementos |
| 29 | def last: A Retorna o último elemento |
| 30 | def map[B](f: (A) => B): imutável.Set[B] Recalcula todos os elementos usando o método fornecido |
| 31 | def max: A Encontra o elemento maior |
| 32 | def min: A Encontra o elemento mais pequeno |
| 33 | def mkString: String Exibe todos os elementos da coleção como strings |
| 34 | def mkString(sep: String): String Exibe todos os elementos da coleção como strings usando delimitadores |
| 35 | def product: A Retorna o produto de todos os elementos numéricos do conjunto imutável |
| 36 | def size: Int Retorna o número de elementos do conjunto imutável |
| 37 | def splitAt(n: Int): (Set[A], Set[A]) Divide o conjunto imutável em dois contêineres, o primeiro contendo os n primeiros elementos e o segundo contendo os elementos restantes |
| 38 | def subsetOf(that: Set[A]): Boolean Se o conjunto contiver um subconjunto, retorna true, caso contrário, retorna false |
| 39 | def sum: A Retorna a soma de todos os elementos numéricos do conjunto imutável |
| 40 | def tail: Set[A] Retorna todos os elementos do conjunto imutável exceto o primeiro |
| 41 | def take(n: Int): Set[A] Retorna os n primeiros elementos |
| 42 | def takeRight(n: Int): Set[A] Retorna os n últimos elementos |
| 43 | def toArray: Array[A] Converte o conjunto em um array |
| 44 | def toBuffer[B >: A]: Buffer[B] Retorna um Buffer, contendo todos os elementos do conjunto imutável |
| 45 | def toList: List[A] Retorna uma Lista, contendo todos os elementos do conjunto imutável |
| 46 | def toMap[T, U]: Map[T, U] Retorna um Map, contendo todos os elementos do conjunto imutável |
| 47 | def toSeq: Seq[A] Retorna um Seq, contendo todos os elementos do conjunto imutável |
| 48 | def toString(): String Retorna uma string representando o objeto |
Mais métodos podem ser consultados Documentação da API