Пакет scala.jdk

Содержит методы-фабрики для построения накопителей.

Обратите внимание, что сам объект Accumulator не является фабрикой, но он неявно преобразуется в фабрику в соответствии с типом элемента, см. Accumulator.toFactory.

Это позволяет передавать объект Accumulator в качестве аргумента, когда требуется коллекция.Фабрика, и используется неявный экземпляр Accumulator.AccumulatorFactoryShape, чтобы создать специализированный накопитель в соответствии с типом элемента:

scala> val intAcc = Accumulator(1,2,3)
intAcc: scala.collection.convert.IntAccumulator = IntAccumulator(1, 2, 3)

scala> val anyAccc = Accumulator("K")
anyAccc: scala.collection.convert.AnyAccumulator[String] = AnyAccumulator(K)

scala> val intAcc2 = List(1,2,3).to(Accumulator)
intAcc2: scala.jdk.IntAccumulator = IntAccumulator(1, 2, 3)

scala> val anyAcc2 = List("K").to(Accumulator)
anyAcc2: scala.jdk.AnyAccumulator[String] = AnyAccumulator(K)

Этот объект предоставляет методы расширения для преобразования между коллекциями Scala и Java.

При написании кода Java используйте явные методы преобразования, определенные в javaapi.CollectionConverters.

Примечание: для создания потоков Java, которые работают с коллекциями Scala (последовательно или параллельно), используйте StreamConverters.

import scala.jdk.CollectionConverters._
val s: java.util.Set[String] = Set("one", "two").asJava

Преобразования возвращают адаптеры для соответствующего API, т. е. коллекции оборачиваются, а не преобразуются. Изменения в исходной коллекции отражаются в представлении и наоборот:

scala> import scala.jdk.CollectionConverters._

scala> val s = collection.mutable.Set("one")
s: scala.collection.mutable.Set[String] = HashSet(one)

scala> val js = s.asJava
js: java.util.Set[String] = [one]

scala> js.add("two")

scala> s
res2: scala.collection.mutable.Set[String] = HashSet(two, one)

Следующие преобразования поддерживаются через asScala и asJava.

scala.collection.Iterable       <=> java.lang.Iterable
scala.collection.Iterator       <=> java.util.Iterator
scala.collection.mutable.Buffer <=> java.util.List
scala.collection.mutable.Set    <=> java.util.Set
scala.collection.mutable.Map    <=> java.util.Map
scala.collection.concurrent.Map <=> java.util.concurrent.ConcurrentMap

Следующие преобразования поддерживаются через asScala и через специально названные методы расширения для преобразования в коллекции Java, как показано:

scala.collection.Iterable    <=> java.util.Collection   (via asJavaCollection)
scala.collection.Iterator    <=> java.util.Enumeration  (via asJavaEnumeration)
scala.collection.mutable.Map <=> java.util.Dictionary   (via asJavaDictionary)

Кроме того, следующие односторонние преобразования предоставляются через asJava.

scala.collection.Seq         => java.util.List
scala.collection.mutable.Seq => java.util.List
scala.collection.Set         => java.util.Set
scala.collection.Map         => java.util.Map

Следующее одностороннее преобразование предоставляется через asScala.

java.util.Properties => scala.collection.mutable.Map

Во всех случаях преобразование из исходного типа в целевой тип и обратно вернёт исходный объект. Например:

import scala.jdk.CollectionConverters._

val source = new scala.collection.mutable.ListBuffer[Int]
val target: java.util.List[Int] = source.asJava
val other: scala.collection.mutable.Buffer[Int] = target.asScala
assert(source eq other)

Этот объект предоставляет методы расширения для преобразования между типами продолжительности Scala и Java.

При написании кода Java используйте явные методы преобразования, определенные в javaapi.DurationConverters.

Этот объект предоставляет методы расширения для преобразования между типами функций Scala и Java.

При написании кода Java используйте явные методы преобразования, определенные в javaapi.FunctionConverters.

Использование метода расширения .asJava для функции Scala генерирует наиболее специфичный возможный тип функции Java:

scala> import scala.jdk.FunctionConverters._
scala> val f = (x: Int) => x + 1

scala> val jf1 = f.asJava
jf1: java.util.function.IntUnaryOperator = ...

Более общие типы функций Java можно создать, используя соответствующий метод расширения asJavaXYZ.

scala> val jf2 = f.asJavaFunction
jf2: java.util.function.Function[Int,Int] = ...

scala> val jf3 = f.asJavaUnaryOperator
jf3: java.util.function.UnaryOperator[Int] = ...

Преобразование функции Java в Scala выполняется с помощью метода расширения asScala.

scala> List(1,2,3).map(jf2.asScala)
res1: List[Int] = List(2, 3, 4)

Этот объект предоставляет методы расширения для преобразования между Scala Future и Java CompletionStage.

При написании кода Java используйте явные методы преобразования, определенные в javaapi.FutureConverters.

Обратите внимание, что мост реализован на стороне только для чтения асинхронных обработчиков, а именно Future (вместо scala.concurrent.Promise) и CompletionStage (вместо java.util.concurrent.CompletableFuture). Это сделано намеренно, поскольку семантика моста для обработчиков записи может привести к гонкам; если оба конца (CompletableFuture и Promise) завершатся независимо одновременно, они могут содержать разные значения впоследствии. По этой причине toCompletableFuture не поддерживается на созданных CompletionStage.

Этот объект предоставляет расширяющие методы, которые преобразуют между типами Scala Option и Java Optional.

При написании кода Java используйте явные методы преобразования, определенные в javaapi.OptionConverters вместо этого.

Тип Scala Option расширен методом toJava, который создает соответствующий тип Optional, и методом toJavaPrimitive, который создает специализированный вариант (например, OptionalInt), если применимо.

Тип Java Optional расширен методом toScala и методом toJavaPrimitive.

Наконец, специализированные типы Optional расширены методами toScala и toJavaGeneric.

Пример использования:

import scala.jdk.OptionConverters._
val a = Option("example").toJava      // Creates java.util.Optional[String] containing "example"
val b = (None: Option[String]).toJava // Creates an empty java.util.Optional[String]
val c = a.toScala                     // Back to Option("example")
val d = b.toScala                     // Back to None typed as Option[String]
val e = Option(2.7).toJava            // java.util.Optional[Double] containing boxed 2.7
val f = Option(2.7).toJavaPrimitive   // java.util.OptionalDouble containing 2.7 (not boxed)
val g = f.toScala                     // Back to Option(2.7)
val h = f.toJavaGeneric               // Same as e
val i = e.toJavaPrimitive             // Same as f

Этот объект предоставляет расширяющие методы для создания потоков Java, которые работают с коллекциями Scala (последовательно или параллельно). Для получения дополнительной информации о потоках Java, обратитесь к документации (https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html).

При написании кода Java используйте явные методы преобразования, определенные в javaapi.StreamConverters вместо этого.

Методы asJavaSeqStream и asJavaParStream преобразуют коллекцию в поток Java:

scala> import scala.jdk.StreamConverters._

scala> val s = (1 to 10).toList.asJavaSeqStream
s: java.util.stream.IntStream = java.util.stream.IntPipeline$Head@7b1e5e55

scala> s.map(_ * 2).filter(_ > 5).toScala(List)
res1: List[Int] = List(6, 8, 10, 12, 14, 16, 18, 20)

Примечание: использование параллельных потоков в Scala REPL приводит к тупиковым ситуациям, см. https://github.com/scala/bug/issues/9076. В качестве обходного решения используйте scala -Yrepl-class-based.

scala> def isPrime(n: Int): Boolean = !(2 +: (3 to Math.sqrt(n).toInt by 2) exists (n % _ == 0))
isPrime: (n: Int)Boolean

scala> (10000 to 1000000).asJavaParStream.filter(isPrime).toScala(Vector)
res6: scala.collection.immutable.Vector[Int] = Vector(10007, 10009, 10037, 10039, ...

Поток Java Stream предоставляет операции над последовательностью элементов. Потоки создаются из Spliterator, которые похожи на Iterators с дополнительной возможностью разделять некоторые свои элементы. Это разделение, если поддерживается Spliterator, используется для паралелизации операций Stream.

Коллекции Scala имеют метод stepper, который возвращает scala.collection.Stepper для коллекции, который в свою очередь может быть преобразован в Spliterator для создания потока Java.

Расширяющий метод asJavaSeqStream доступен для любой коллекции Scala. Расширяющий метод asJavaParStream может быть вызван только для коллекций, где тип возвращаемого значения метода stepper помечен маркером scala.collection.Stepper.EfficientSplit. Этот маркер добавляется к степерам, которые поддерживают разделение и, следовательно, эффективную параллельную обработку.

Доступны следующие расширяющие методы:

Метод asJavaPrimitiveStream преобразует Stream[Int] в IntStream. Это дуальная функция метода boxed, определенного для примитивных потоков (например, IntStream.boxed является Stream[Integer]).

Расширяющие методы toScala для потоков Java собирают результат потоковой обработки в коллекцию Scala, например, stream.toScala(List), stream.toScala(Vector). Обратите внимание, что операции преобразования над потоками ленивые (также называемые «промежуточными»), терминальные операции, такие как forEach, count или toScala, запускают вычисление.

Сбор параллельного потока в коллекцию можно выполнять параллельно. Это полезно, если целевая коллекция поддерживает эффективное объединение сегментов, созданных параллельно. Для поддержки этого случая стандартная библиотека Scala предоставляет коллекцию Accumulator. Эта коллекция поддерживает эффективное параллельное создание, и она имеет специализированные подтипы для Int, Long и Double, поэтому примитивные потоки Java можно собирать в коллекцию Scala без упаковки элементов.