目录
目前开发语言众多，在开发中，可能会遇到Java，Scala混合系统，但因java，scala中的集合对象不一致，会致使在开发中遇到很多问题，得需要两种语言集合的互相转换。Scala从2.8.1开始引入scala.collection.JavaConverters用于Scala与Java集合的互转，在scala代码中如果需要集合转换，首先引入scala.collection.JavaConverters._，进而显示调用asJava或者asScala方法完成转型。与此雷同的scala.collection.JavaConversions已被标注为@Deprecated（since 2.12.0），JavaConversions可以做到隐式转换，即不需要asJava或者asScala的调用，但是这样可能会对阅读造成障碍，可能会让人难以知晓什么变成了什么。以下为Scala源码注释。
scala、java双向转化
以下集合可以进行任意，转换。但在某些情况下引入的隐式转换不正确或未引入，仍然无法进行正确转换，如API的例子
scala.collection.Iterable <=> java.lang.Iterable
scala.collection.Iterable <=> java.util.Collection
scala.collection.Iterator <=> java.util.{ Iterator, Enumeration }
scala.collection.mutable.Buffer <=> java.util.List
scala.collection.mutable.Set <=> java.util.Set
scala.collection.mutable.Map <=> java.util.{ Map, Dictionary }
scala.collection.concurrent.Map <=> java.util.concurrent.ConcurrentMap
Scala的collection可以指定元素排序规则：sort方法或继承comparable
scala.collection.Iterable<=>java.lang.{iterable,collection}
scala.collection.Iterator<=>java.util.{Iterator,Enumeration}
scala的Buffer对应就是java.util.List,但不可直接使用，使用ListBuffer
scala.collection.mutable.Buffer<=>java.util.List
scala.collection.mutable.Set<=>java.util.Set
scala.collection.mutable.Map<=>java.util.{Map,Dictionary}
并发安全集合
scala.collection.concurrent.Map<=>java.util.concurrent.ConcurrentMap
在所有情形下，从原始类型转变到对侧类型之后再转变回来的话会是同一个对象
scala.collection.mutable.ListBuffer<=>java.util.List中除要求引入相应的转换类JavaConversions._，还有引入ListBuffer=>java.util.List 具体转换方法
package com.fuyun.bigdata.scala.collection
import scala.collection.mutable
/**
* Scala中如何将Java集合实例对象转换为Scala实例对象（互相转换）
*/
object ConvertorScalaDemo {
def main(args: Array[String]): Unit = {
// 定义Java中的Map实力对象
import java.util
val hashMap = new util.HashMap[String, Int]()
hashMap.put("spark", 555)
hashMap.put("hive", 666)
hashMap.put("scala", 123)
hashMap.put("linux", 345)
hashMap.put("hbase", 234)
// TODO：将Java中HashMap集合转换为Scala中Map集合实例对象
import scala.collection.JavaConverters._
val map: mutable.Map[String, Int] = hashMap.asScala // 隐式转换
map.foreach(println(_))
println("======================================")
// TODO: 将Scala中列表转换为Java中列表
val list: List[String] = List("hive", "spark", "kafka", "hbase", "java")
val lst: util.List[String] = list.asJava
println(lst)
println("======================================")
/**
* 在所有情形下，从原始类型转变到对侧类型之后再转变回来的话会是同一个对象
* Scala中的ListBuffer与Java中List相互转换时，
* 不仅要导入scala.collection.JavaConverters._，
* 还有导入以下两个包
*/
import scala.collection.JavaConversions.bufferAsJavaList
import scala.collection.JavaConversions.asScalaBuffer
val slstl = new scala.collection.mutable.ListBuffer[Int]
val jlstl: java.util.List[Int] = slstl
val slst2: scala.collection.mutable.Buffer[Int] = jlstl
println("两者集合是否相等：" + (slstl eq slst2))
}
}
结果为：
(hive,666)
(spark,555)
(scala,123)
(linux,345)
(hbase,234)
======================================
[hive, spark, kafka, hbase, java]
======================================
两者集合是否相等：true
Process finished with exit code 0
通过asJava进行Scala到Java的单向转换
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到Scala的单向转换
java.util.Properties => scala.collection.mutable.Map
具体描述性的名称显示调用
Scala转Java
如果在进行java集合对象与scala集合对象的转换时，引入import scala.collection.JavaConversions._后仍然无法转换，
则尝试引入你要转换的集合类型对应的具体隐式转换方法，方法如下：
// 隐式转换一个scala iterable为一个不可变的java.collection
implicit def asJavaCollection[A](it:iterable[A]):collection[A]
// 隐式转换一个scala iterable 为一个java Dictionary
implicit def asJavaDictionary[A,B](m:mutable.Map[A,B]):Dictionary[A,B]
// 隐式转换一个scala iterable为一个java Enumeration
implicit def asJavaEnumeration[A](it:Iterator[A]):java.util.Enumeration
// 隐式转换一个scala iterable为一个java Iterable
implicit def asJavaIterable[A](i:iterable[A]):java.lang.Iterable[A]
// 隐式转换一个scala iterator 为一个java iterator
implicit def asJavaIterator[A](it:Iterator[A]):java.lang.Iterator
// 隐式一个scalaBuffer（用其实现Buffer接口，AbstractBuffer抽象类的子类作为接受对象）为java.util.list
implicit def bufferAsJavaList[A](s:java.util.Set[A]):java.util.list
// 隐式转换一个Scala.mutable.concurrent.Map转换为java.concurrent.ConcurrentMap
implicit def mapAsJavaConcurrentMap[A,B)(m:concurrent.Map[A,B]):ConcurrentMap[A,B]
// 隐式转换一个scala.Map转换为java map对象
implicit def mapAsJavaMap[A,B](m:Map[A,B]):java.util.Map[A,B]
// 隐式转换一个 scala.mutable.Map转换为一个 java.util.Map对象
implicit def mutableMapAsJavaMap[A,B](m:mutable.Map[A,B]):java.util.Map[A,B]
// 隐式转换一个scala.mutable.Seq转换为一个java.util.List对象
implicit def mutableSeqAsJavaList[A,B](m:mutable.Seq[A,B]):java.util.List[A,B]
// 隐式将一个 scala.mutable.Seq转换为一个java.util.Set对象
implicit def mutableSetAsJavaSet[A,B](m:mutable.Set[A,B]):java.util.Set[A,B]
Java转Scala
// 隐式转换一个java.util.list对象为scalaBuffer（用其实现Buffer接口，AbstractBuffer抽象类的子类作为接受对象）
implicit def asScalaBuffer[A](l:java.util.List[A]):Buffer[A]
// 隐式转换一个java.util.iterator对象为scala.iterator
implicit def asScalaIterator[A](it:java.util.Iterator[A]):Iterator[A]
// 隐式转换一个java.util.Set 为mutable.Set
implicit def asScalaSet[A](s:java.util.Set[A]):mutable.Set
// 隐式转换一个java.collection对象为scala.iterable
implicit def collectionAsScalaIterable[A](i:Collection[A]):Iterable[A]
// 隐式转换一个java.Dictionary 对象转换为Scala.mutable.Map[String,String]
implicit def dictionaryAsScalaMap[A,B](p:Dictionary[A,B]):mutable.Map[A,B]
// 隐式将一个java.Enumeration 对象转换为Scala.iterator对象
implicit def enumerationAsScalaIterator[A](i:java.lang.Enumeration[A]):Iterator[A]
// 隐式将一个java.Iterable对象转换为Scala.iterable对象
implicit def iterableAsScalaIterable[A](i:java.lang.Iterable[A]):Iterable[A]
// 隐式将一个java concurrentMap 转换为一个scala.concurrentMap对象
implicit def mapAsScalaConcurrentMap[A,B](m:ConcurrentMap[A,B]):concurrent.Map[A,B]
// 隐式将一个java.util.Map 转换为一个scala.Map 对象
implicit def mapAsScalaMap[A,B](m:java.util.Map[A,B]):mutable.Map[A,B]
// 隐式将一个 java Properties 转换为一个 mutable.Map对象
implicit def propertiesAsScalaMap(p:Properties):mutable.Map[String,String]
// 隐式将一个scala.Seq 转换为一个 java.util.List 对象
implicit def seqAsJavaList[A](seq:Seq[A]):java.util.List[A]
// 隐式将一个scala.Set 转换为一个 java.util.Set 对象
implicit def setAsJavaSet[A](set:Set[A]):java.util.Set[A]