Scala Language
जावा इंटरऑपरेबिलिटी

जावा कलेक्शन और इसके विपरीत स्कैला कलेक्शन को बदलना

जब आपको एक जावा विधि में एक संग्रह पास करने की आवश्यकता होती है:

import scala.collection.JavaConverters._

val scalaList = List(1, 2, 3)
JavaLibrary.process(scalaList.asJava)

यदि जावा कोड जावा संग्रह लौटाता है, तो आप इसे एक समान तरीके से स्काला संग्रह में बदल सकते हैं:

import scala.collection.JavaConverters._

val javaCollection = JavaLibrary.getList
val scalaCollection = javaCollection.asScala

ध्यान दें कि ये डेकोरेटर हैं, इसलिए वे केवल एक स्केला या जावा संग्रह इंटरफ़ेस में अंतर्निहित संग्रह को लपेटते हैं। इसलिए, कॉल .asJava और .asScala संग्रह की प्रतिलिपि नहीं बनाते हैं।

Arrays

Arrays नियमित रूप से JVM सरणियाँ हैं जिन्हें एक मोड़ के साथ माना जाता है कि उन्हें अपरिवर्तनीय माना जाता है और उनके पास विशेष निर्माता और निहित रूपांतरण हैं। new कीवर्ड के बिना उनका निर्माण करें।

 val a = Array("element")

अब a प्रकार का Array[String] ।

 val acs: Array[CharSequence] = a
 //Error: type mismatch;  found   : Array[String]  required: Array[CharSequence]

हालाँकि String , CharSequence लिए परिवर्तनीय है, Array[String] Array[CharSequence] लिए परिवर्तनीय नहीं है Array[CharSequence] ।

आप एक का उपयोग कर सकते Array अन्य संग्रह, के लिए एक अंतर्निहित रूपांतरण करने के लिए धन्यवाद की तरह TraversableLike ArrayOps :

 val b: Array[Int] = a.map(_.length)

स्काला संग्रह (के अधिकांश TraversableOnce ) एक है toArray विधि एक अंतर्निहित लेने ClassTag परिणाम सरणी के निर्माण के लिए:

 List(0).toArray
 //> res1: Array[Int] = Array(0)

इससे आपके Scala कोड में किसी भी TraversableOnce का उपयोग करना आसान हो जाता है और फिर इसे Java कोड में पास कर दिया जाता है जो किसी सरणी की अपेक्षा करता है।

स्केल और जावा प्रकार रूपांतरण

Scala JavaConverters ऑब्जेक्ट में सभी प्रमुख संग्रह प्रकारों के बीच निहित रूपांतरण प्रदान करता है।

निम्नलिखित प्रकार के रूपांतरण द्विदिश हैं।

कुछ अन्य स्काला संग्रह जावा में भी परिवर्तित किए जा सकते हैं, लेकिन मूल स्काला प्रकार में रूपांतरण नहीं होता है:

संदर्भ :

जावा और स्काला कलेक्शंस के बीच बातचीत

स्काला फ़ंक्शंस के लिए कार्यात्मक इंटरफेस - स्कैला-जावा 8-कॉमर्स

स्काला के लिए एक जावा 8 संगतता किट।

अधिकांश उदाहरण से नकल कर रहे हैं रीडमी

Scala.FunctionN और java.util.function के बीच कन्वर्टर्स

import java.util.function._
import scala.compat.java8.FunctionConverters._

val foo: Int => Boolean = i => i > 7
def testBig(ip: IntPredicate) = ip.test(9)
println(testBig(foo.asJava))  // Prints true

val bar = new UnaryOperator[String]{ def apply(s: String) = s.reverse }
List("cod", "herring").map(bar.asScala)    // List("doc", "gnirrih")

def testA[A](p: Predicate[A])(a: A) = p.test(a)
println(testA(asJavaPredicate(foo))(4))  // Prints false

Scala.Option और java.util कक्षाओं के बीच कन्वर्टर्स वैकल्पिक, OptionalDouble, OptionalInt, और OptionalLong।

import scala.compat.java8.OptionConverters._

    class Test {
      val o = Option(2.7)
      val oj = o.asJava        // Optional[Double]
      val ojd = o.asPrimitive  // OptionalDouble
      val ojds = ojd.asScala   // Option(2.7) again
    }

स्केल संग्रह से जावा 8 स्ट्रीम में कन्वर्टर्स

import java.util.stream.IntStream

import scala.compat.java8.StreamConverters._
import scala.compat.java8.collectionImpl.{Accumulator, LongAccumulator}


  val m = collection.immutable.HashMap("fish" -> 2, "bird" -> 4)
  val parStream: IntStream = m.parValueStream
  val s: Int = parStream.sum
  // 6, potientially computed in parallel
  val t: List[String] = m.seqKeyStream.toScala[List]
  // List("fish", "bird")
  val a: Accumulator[(String, Int)] = m.accumulate // Accumulator[(String, Int)]

  val n = a.stepper.fold(0)(_ + _._1.length) +
    a.parStream.count // 8 + 2 = 10

  val b: LongAccumulator = java.util.Arrays.stream(Array(2L, 3L, 4L)).accumulate
  // LongAccumulator
  val l: List[Long] = b.to[List] // List(2L, 3L, 4L)