Scala的import机制总结

Scala的import机制总结

import 主要用于导入各种名字空间（package）或其包含的成员，使它们在声明的作用域里可见。

1 导入package

  访问package的成员需要用导入的package名作为前缀，主要用于当package嵌套较多时，可以起到简化及隔离名字空间的作用。

  当然任何时候使用完整package路径（full package path）都是可以的。如：

 

  import java.util
  new util.ArrayList[String]() // 需要有util作为前缀，省略掉util的父package “java”
  new java.util.ArrayList[String] // 通过完整package路径访问

  import java.sql
  new sql.Date(new util.Date().getTime) // 使用package名隔离Date类的名字冲突

2 导入package下所有成员

  相比Java中使用‘*’，Scala使用'_'表示导入package下所有成员. 

  如：

 

scala> val map = new HashMap[String,Int]
<console>:7: error: not found: type HashMap
       val map = new HashMap[String,Int]
                     ^
scala> import scala.collection.immutable.HashMap
import scala.collection.immutable.HashMap

scala> var map = new HashMap[String,Int]
map: scala.collection.immutable.HashMap[String,Int] = Map()

scala> map += "itang" -> 1

scala> map
res1: scala.collection.immutable.HashMap[String,Int] = Map(itang -> 1)

scala> import java.util._
scala> new ArrayList[String]()

 

3 导入package下特定成员

  指定package路径及要导入的类等的名称，如：

 

import java.util.ArrayList
new ArrayList[Int]

4 导入package下特定成员，并重命名

  在要导入package后使用"{}",指定要导入的成员，并使用"=>"重命名;如果在一个package下要导入多个成员，则使用逗号分隔.如:

 

scala> import java.util.{ArrayList => JList, HashMap => JMap}
scala> new JList[Int]
res: java.util.ArrayList[Int] = []

scala> type JStringList = JList[String]
defined type alias JStringList

scala> new JStringList
res: java.util.ArrayList[String] = []

scala> new JMap[String, String]
res: java.util.HashMap[String,String] = {}

scala> import scala.Option.{empty => jempty}
scala> jempty
res: Option[Nothing] = None

5 导入package object的成员

  scala中package除了充当命名空间之外，还可以通过package object可定义一些成员，形如：

 

package test

package object utils {
  type JStringList = java.util.ArrayList[String]
  val Msg = "Hello, World"
  implicit def iw(target: Int) = new {
	  def times(proc: => Any) {
		  var i = 0
		  while (i < target) {
			  proc
			  i += 1
		  }
	  }
  }
}

 

import test.utils._
object tt extends App {
  println(Msg)
  new JStringList
  10.times(println("hello"))
}

6 导入object的成员

  Scala中是没有Java中类中静态成员的概念，反之，Scala使用object class（对象类型）单例模式

  Scala能导入object class的成员，也能导入运行时对象实例的成员。

 

scala> import scala.Option._
scala> empty
res: Option[Nothing] = None 

case class User(name: String, age: Int)
val a = new User("itang", 18)
println("%s's age is %d" format (a.name, a.age))

import a._
println("%s's age is %d", name, age) //output: itang's age is 18

 

7 import 可以位于表达式的能放的任意位置，而且导入的成员有其“可见”的作用域

  如一下代码所示：

 

import scala.actors.Actor._

class TestPackagePosScope extends App {
  actor {
	  println("Hello")
  }
  //new HashSet[String] ///not found type: HashSet
  import collection.immutable.HashSet
  new HashSet[String]

  def test1() {
	  import java.text.{ SimpleDateFormat => Sdf }
	  import java.util.Date
	  new Sdf("yyyy-MM-dd").format(new Date)
  }

  //new Sdf("yyyy-MM-dd").format(new Date) //not found type: Sdf
  {
	  import java.util._
	  val jlist = new ArrayList[String]
  }
  //val badJlist = new ArrayList[String] // not found type: ArrayList
}

  

  import 使用上像表达式，但它不是表达式也不是函数，它没有返回值，存在于编译时，如

  scala> val some = import java.util._

  <console>:1: error: illegal start of simple expression

         val some = import java.util._

8 scala默认已导入的名字空间及成员

 scala包下成员默认可见

  相当与每个编译单元里默认import scala._

 

scala> Console.println("hello") // scala.Console
scala> Seq(1,2)
scala> scala.Seq(1,2)

 注意到scala也是一个package object，里面定义了很多不同package的下类型别名，如此可以将众多的类型组织到scala名字空间。

 

  java.lang包下成员默认可见

  相当与每个编译单元里默认import java.lang._ 

 

scala> Runtime.getRuntime.availableProcessors // java.lang.Runtime
scala> System.getProperty("user.home")

 

  scala.Predef 这个object下成员默认可见（主要定义全局函数，类型别名，隐式转换等等)

  相当与每个编译单元里默认import scala.Predef._

 

scala> println("hello")
scala> scala.Predef.println("hell")
scala> "msg" -> "Hello"
scala> any2ArrowAssoc("msg").->("Hello") //scala.Predef.any2ArrowAssoc