Set集合 #

val set1 = Set(1, 2, 3, 4, 5)
val set2 = Set(1, 1, 2, 2, 3)
val set3 = Set.empty[Int]
val set4 = Set.fill(5)(scala.util.Random.nextInt(10))

val set = Set(1, 2, 3, 4, 5)

set.size
set.isEmpty
set.nonEmpty
set.head
set.last
set.tail
set.take(3)
set.drop(2)

val set = Set(1, 2, 3)

val set1 = set + 4
val set2 = set + (4, 5, 6)
val set3 = set ++ Set(4, 5, 6)

val set = Set(1, 2, 3, 4, 5)

val set1 = set - 3
val set2 = set - (1, 2)
val set3 = set -- Set(1, 2, 3)

val set1 = Set(1, 2, 3, 4)
val set2 = Set(3, 4, 5, 6)

val union = set1 | set2
val union2 = set1 ++ set2
val union3 = set1.union(set2)

val intersect = set1 & set2
val intersect2 = set1.intersect(set2)

val diff = set1 &~ set2
val diff2 = set1.diff(set2)
val diff3 = set1 -- set2

val set1 = Set(1, 2, 3)
val set2 = Set(1, 2, 3, 4, 5)

set1.subsetOf(set2)
set2.subsetOf(set1)
set1 == set2

val set = Set(1, 2, 3, 4, 5)

set.contains(3)
set(3)
set.find(_ > 3)
set.filter(_ > 3)
set.filterNot(_ > 3)

val set = Set(1, 2, 3, 4, 5)

set.isEmpty
set.nonEmpty
set.exists(_ > 3)
set.forall(_ > 0)

val set = Set(1, 2, 3, 4, 5)

set.map(_ * 2)
set.flatMap(n => Set(n, n * 2))
set.groupBy(_ % 2)
set.partition(_ > 3)

val set = Set(1, 2, 3, 4, 5)

set.sum
set.product
set.min
set.max
set.reduce(_ + _)
set.fold(0)(_ + _)

import scala.collection.mutable

val set = mutable.Set(1, 2, 3)
val empty = mutable.Set.empty[Int]

import scala.collection.mutable

val set = mutable.Set(1, 2, 3)

set += 4
set += (5, 6)
set ++= Set(7, 8)
set.add(9)

import scala.collection.mutable

val set = mutable.Set(1, 2, 3, 4, 5)

set -= 3
set -= (1, 2)
set --= Set(4, 5)
set.remove(6)
set.clear()

import scala.collection.mutable

val set = mutable.Set(1, 2, 3)

set.update(2, true)
set.update(4, true)
set.update(1, false)

val hashSet = scala.collection.immutable.HashSet(1, 2, 3, 4, 5)

import scala.collection.immutable.TreeSet

val treeSet = TreeSet(3, 1, 4, 1, 5, 9, 2, 6)
println(treeSet)

val reverseSet = TreeSet(3, 1, 4, 1, 5)(Ordering[Int].reverse)

import scala.collection.mutable.LinkedHashSet

val linkedSet = LinkedHashSet(3, 1, 4, 1, 5)
println(linkedSet)

import scala.collection.immutable.SortedSet

val sorted = SortedSet(3, 1, 4, 1, 5, 9, 2, 6)
println(sorted)

val list = List(1, 1, 2, 2, 3, 3, 4, 4, 5)
val unique = list.toSet.toList

val words = List("apple", "banana", "apple", "cherry", "banana")
val uniqueWords = words.toSet

def commonElements(list1: List[Int], list2: List[Int]): List[Int] =
  list1.toSet.intersect(list2.toSet).toList

val result = commonElements(List(1, 2, 3, 4), List(3, 4, 5, 6))

def uniqueToFirst(list1: List[Int], list2: List[Int]): List[Int] =
  list1.toSet.diff(list2.toSet).toList

val result = uniqueToFirst(List(1, 2, 3, 4), List(3, 4, 5, 6))

case class Article(title: String, tags: Set[String])

val articles = List(
  Article("Scala Intro", Set("scala", "programming")),
  Article("Java Basics", Set("java", "programming")),
  Article("Python Tips", Set("python", "programming")),
  Article("Scala Advanced", Set("scala", "advanced"))
)

def findByTag(tag: String): List[Article] =
  articles.filter(_.tags.contains(tag))

def findByTags(tags: Set[String]): List[Article] =
  articles.filter(a => tags.subsetOf(a.tags))

findByTag("scala")
findByTags(Set("scala", "programming"))