您所在的位置： &
4，动手实战Scala中的隐式转换、隐式参数、隐式类
4，动手实战Scala中的隐式转换、隐式参数、隐式类
机械工业出版社
《Spark亚太研究院系列丛书――Spark实战高手之路 从零开始》本书通过Spark的shell测试Spark的工作；使用Spark的cache机制观察一下效率的提升构建Spark的IDE开发环境；通过Spark的IDE搭建Spark开发环境；测试Spark IDE开发环境等等。本节为大家介绍动手实战Scala中的隐式转换、隐式参数、隐式类。
4，动手实战Scala中的隐式转换、隐式参数、隐式类
隐式转换是很多人学习Scala的难点，这是Scala的精髓之一：
下面看一下隐藏参数的例子：
上面的例子中使用了隐式参数，当然，你可以显示的指明参数：
下面看一下隐式类：
喜欢的朋友可以添加我们的微信账号：
51CTO读书频道二维码
51CTO读书频道活动讨论群：【责任编辑： TEL：（010）】&&&&&&
关于&&&&&&&&&&&&&&的更多文章
Docker是一个轻量级虚拟机，也是一种Linux容器，它突破了以往的
本书描述了黑客用默默无闻的行动为数字世界照亮了一条道路的故事。
讲师： 21人学习过讲师： 30人学习过讲师： 36人学习过
大数据时代，R语言已成为数据分析的利器，是挖掘数据
本书在总结多年来MapReduce并行处理技术课程教学经验
本书为日本公认的最好的Ruby入门教程。松本行弘亲自审
本书第1版曾被KDnuggets的读者评选为最受欢迎的数据挖掘专著，是一本可读性极佳的教材。它从数据库角度全面系统地介绍了数据挖掘
51CTO旗下网站第五讲&&Scala隐式转换和并发编程
Scala隐式转换和并发编程
隐式转换就是超人的概念。要这个方法，没有的时候，根据规则转换类型，再调用方法。
隐式转换的函数implicit
conversion function&
会根据隐式转换函数的签名，转换成另外一种对象。
Implicit def
rddToPairRDDFunctions[K,V](rdd:RDD[(K,V)])
scala& class Person(val name:String)
defined class Person
warning: previously defined object Person is not a
companion to class Person.
Companions must you may wish
to use :paste mode for this.
scala& class Engineer(val name:String,val
salary:Double){
| def code=println("Coding ......")
defined class Engineer
scala& def toCode(p:Person){
:19: error: value code is not a member of
Person& //code方法不是Person类的，需要隐式转换函数
scala& implicit def
PersonToEngineer(p:Person):Engineer={
| new Engineer(p.name,10000)
warning: there were 1 feature warning(s); re-run
with -feature for details
PersonToEngineer: (p: Person)Engineer
scala& def toCode(p:Person){
toCode: (p: Person)Unit
scala& toCode(new
Person("Scala"))& //实际返回的是engineer对象
Coding .....
Package com.dt.scala.implicits
Import scala.io.Source
Import java.io.File
class RicherFile(val file:File){
def read=Source.fromFile(file.getPath()).mkstring
class File_Implicits(path:String) extends
File(path)
object File_Implicits{
implicit def file2RicherFile(file:File) = new
RicherFile(file)
object Implicits_Internals{
def main(args:Array[String]){
&&&&&&&&&&&&&&&
val file = new File_Implicits(“content.txt”)
&&&&&&&&&&&&&&&
println(file.read)
Implicit val
Implicit var
隐式参数类型的伴生对象中去找隐式值
scala& class Level(val level:Int)
defined class Level
scala& def toWorker(name:String)(implicit
l:Level)=println(name+": "+l.level)
toWorker: (name: String)(implicit l:
Level)Unit
scala& implicit val level = new
level: Level = Level@38c6f088
scala& toWorker("Spark")
scala& abstract class Template[T]{
| def add(x:T,y:T):T
defined class Template
scala& abstract class SubTemplate[T] extends
Template[T]{
| def unit:T
defined class SubTemplate
scala& object Implicits_Object{
| def main(args:Array[String]){
| implicit object StringAdd extends SubTemplate[String]{
| override def add(x:String,y:String)=x concat y
| override def unit:String=""
| implicit object IntAdd extends SubTemplate[Int]{
&&| override def
add(x:Int,y:Int)=x+y
| override def unit:Int=0
| def sum[T](xs:List[T])(implicit m:SubTemplate[T]):T=
| if(xs.isEmpty) m.unit
| else m.add(xs.head,sum(xs.tail))
| println(sum(List(1,2,3,4,5,6)))
| println(sum(List("Spark ","Scala ","Kafka")))
defined module Implicits_Object
更加逆天的是隐式类，上下文去隐式类中找有的没得方法。
并发编程+缓存是编程高手必须的。高效利用cpu。Thread是java的成功和失败，成功是应用了物理硬件，失败是基于共享全局变量的加锁机制，不可避免的死锁和状态失控。
分布式系统，一个黄金准则，不要共享全局变量，造成死锁。
Scala是Actor，变量是私有的，不会共享变量，不会死锁。
基于Actor有一个经典的框架，Akka。
scala& class HiActor extends Actor{
| def act(){
| while(true){
| receive {
| case name:String=&println(name)
defined class HiActor
scala& val actor=new HiActor
actor: HiActor = HiActor@66746f57
scala& actor.start()
res1: scala.actors.Actor =
HiActor@66746f57
scala& actor ! "Spark"&
！是异步，一定要结果 !?& !!
获得结果，未来某个时间一定获得结果
scala& case class
Basic(name:String,age:Int)
defined class Basic
scala& case class
Worker(name:String,age:Int)
defined class Worker
scala& class BasicActor extends
| def act(){
| receive{
| case Basic(name,age)=&println("Basic information name is
"+name+":"+age)
| case Worker(name,age)=&println("Worker information name is
"+name+":"+age)
defined class BasicActor
scala& val b=new BasicActor
b: BasicActor = BasicActor@57fae983
scala& b.start
res4: scala.actors.Actor =
BasicActor@57fae983
scala& b ! Basic("Scala",8)
Basic information name is Scala:8
scala& b ! Worker("Spark",6)
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。Scala 隐式转换 - 简书
Scala 隐式转换
什么是隐式转换
我们经常引入第三方库，但当我们想要扩展新功能的时候通常是很不方便的，因为我们不能直接修改其代码。scala提供了隐式转换机制和隐式参数帮我们解决诸如这样的问题。Scala中的隐式转换是一种非常强大的代码查找机制。当函数、构造器调用缺少参数或者某一实例调用了其他类型的方法导致编译不通过时，编译器会尝试搜索一些特定的区域，尝试使编译通过。
场景一，现在我们要为Java的File类提供一个获得所有行数的方法：
implicit class Files(file: File) {
def lines: Array[String] = {
val fileReader: FileReader = new FileReader(file)
val reader = new BufferedReader(fileReader)
var lines = Array[String]()
var line = reader.readLine()
while (line != null) {
lines = lines :+ line
line = reader.readLine()
} finally {
fileReader.close()
reader.close()
private val file: File = new File("/path/to")
file.lines foreach println
场景二，我期望可以像操作集合那样来操作一个文件中的所有行。比如，对所有的行映射（map）一个指定函数。
implicit def file2Array(file: File): Array[String] = file.lines
def map[R](source: Array[String])(fn: String => R) = {
source.map(fn)
map(new File("/path/to"))(println)
隐式操作规则
标记规则：只有标记为implicit的变量，函数或对象定义才能被编译器当做隐式操作目标。
作用域规则：插入的隐式转换必须是单一标示符的形式处于作用域中，或与源/目标类型关联在一起。单一标示符是说当隐式转换作用时应该是这样的形式：file2Array(arg).map(fn)的形式，而不是foo.file2Array(arg).map的形式。假设file2Array函数定义在foo对象中，我们应该通过import foo._或者import foo.file2Array把隐式转换导入。简单来说，隐式代码应该可以被"直接"使用，不能再依赖类路径。假如我们把隐式转换定义在源类型或者目标类型的伴生对象内，则我们可以跳过单一标示符的规则。因为编译器在编译期间会自动搜索源类型和目标类型的伴生对象，以尝试找到合适的隐式转换。
无歧义规则：不能存在多于一个隐式转换使某段代码编译通过。因为这种情况下会产生迷惑，编译器不能确定到底使用哪个隐式转换。
单一调用规则：不会叠加（重复嵌套）使用隐式转换。一次隐式转化调用成功之后，编译器不会再去寻找其他的隐式转换。
显示操作优先规则：当前代码类型检查没有问题，编译器不会尝试查找隐式转换。
隐式解析的搜索范围
隐式转换本身是一种代码查找机制，所以下面会介绍隐式转换的查找范围：-当前代码作用域。最直接的就是隐式定义和当前代码处在同一作用域中。-当第一种解析方式没有找到合适的隐式转换时，编译器会继续在隐式参数类型的隐式作用域里查找。一个类型的隐式作用域指的是与该类型相关联的所有的伴生对象。
对于一个类型T它的隐式搜索区域包括如下：-假如T是这样定义的：T with A with B with C，那么A, B, C的伴生对象都是T的搜索区域。-如果T是类型参数，那么参数类型和基础类型都是T的搜索部分。比如对于类型List[Foo]，List和Foo都是搜索区域-如果T是一个单例类型p.T，那么p和T都是搜索区域。-如果T是类型注入p#T，那么p和T都是搜索区域。
所以，只要在上述的任何一个区域中搜索到合适的隐式转换，编译器都可以使编译通过。
看两个例子：
通过类型参数获得隐式作用域
scala& implicit val i: Int = 1
i: Int = 1
scala& implicitly[Int]
res11: Int = 1
通过嵌套获得隐式作用域
object Foo {
implicit val bar = new Bar {
override def toString = "Foo`s Bar"
object Test extends App {
import Foo.Bar
class B extends Bar
def m(implicit bar: Bar) = println(bar.toString)
转换类型为期望的类型
scala& val i: Int = 3.5
&console&:7: error:
: Double(3.5)
required: Int
val i: Int = 3.5
scala& implicit def double2Int(d: Double) = d.toInt
warning: there was re-run with -feature for details
double2Int: (d: Double)Int
scala& val i: Int = 3.5
i: Int = 3
当我们尝试把一个带有精度的数字复制给Int类型时，编译器会给出编译错误，因为类型不匹配。当我们创建了一个double to int的隐式转换之后编译正常通过。还有一种情况是与新类型的操作。
case class Rational(n: Int, d: Int) {
def +(r: Rational) = Rational(n + r.n, d + r.d)
implicit def int2Rational(v: Int) = Rational(v, 1)
Rational(1, 1) + Rational(1, 1)
1 + Rational(1, 1)
模拟新的语法
比如scala中的arrow（-&）语法就是一个隐式转换
implicit final class ArrowAssoc[A](private val self: A) extends AnyVal {
@inline def -& [B](y: B): Tuple2[A, B] = Tuple2(self, y)
def →[B](y: B): Tuple2[A, B] = -&(y)
类型类是一种非常灵活的设计模式，可以把类型的定义和行为进行分离，让扩展类行为变得非常方便。
@implicitNotFound("No member of type class NumberLike in scope for ${T}")
trait Increasable[T] {
def inc(t: T): T
object Increasable {
implicit object IncreasableInt extends Increasable[Int] {
def inc(t: Int) = t + 1
implicit object IncreasableString extends Increasable[String] {
def inc(t: String) = t + t
def inc[T: Increasable](list: List[T]) = {
val ev = implicitly[Increasable[T]]
list.map(ev.inc)
inc(List(1, 2, 3))
inc(List("z", "a", "b"))
当我们在定义方法时，可以把最后一个参数列表标记为implicit，表示该组参数是隐式参数。一个方法只会有一个隐式参数列表，置于方法的最后一个参数列表。如果方法有多个隐式参数，只需一个implicit修饰即可。当调用包含隐式参数的方法是，如果当前上下文中有合适的隐式值，则编译器会自动为改组参数填充合适的值。如果没有编译器会抛出异常。当然，标记为隐式参数的我们也可以手动为该参数添加默认值。def foo(n: Int)(implicit t1: String, t2: Double = 3.14)
隐式视图：把一种类型转换为其他的类型，转换后的新类型称为视图类型。隐式视图会用于以下两种场景：当传递给函数的参数与函数声明的类型不匹配时；
scala& def log(msg: String) = println(msg)
log: (msg: String)Unit
scala& log("hello world")
hello world
scala& log(123)
&console&:9: error:
: Int(123)
required: String
scala& implicit def int2String(i: Int): String = i.toString
warning: there was re-run with -feature for details
int2String: (i: Int)String
scala& log(123)
当调用foo.bar，并且foo中并没有bar成员时（常用于丰富已有的类库）。
scala& :pas
// Entering paste mode (ctrl-D to finish)
class Strings(str: String) {
def compress = str.filter(_ != ' ').mkString("")
implicit def strings(str: String): Strings = new Strings(str)
// Exiting paste mode, now interpreting.
warning: there was re-run with -feature for details
defined class Strings
strings: (str: String)Strings
scala& " a b c d ".compress
res0: String = abcd
如果细心观察上边的compress的实现和文章开头lines的实现，这两段代码实现功能所采用的思路是类似的。但是，两端代码的实现形式是有区别的。lines的实现采用了scala中的隐式类型特性。隐式类型是scala提供的一种语法糖，隐式类型还是要转换为：类型+隐式视图的形式（也就是compress的形式）。
本文内容整理自《Scala in depth》，《Scala 编程》。23萝卜 的BLOG
用户名：23萝卜
文章数：104
访问量：6302
注册日期：
阅读量：5863
阅读量：12276
阅读量：381002
阅读量：1073145
51CTO推荐博文
集合&&&&list&&&&set&&&&tuple&&&&map访问数据应该是下划线1，2，如hostPort._1。下标是从1开始的。package&cn.chinahadoop.scala
class&Basic5&{
//默认为val
case&class&Book(name:&String,&author:&String)
object&Basic5&extends&App&{
&&//&&val&value&=&3
&&//&&//match是有返回值的
&&//&&val&result&=&value&match&{
&&//&&&&case&1&=&&"one"
&&//&&&&case&2&=&&"two"
&&//&&&&case&_&=&&"some&other&number"
&&//&&println("result&of&match&&is&:"&+&result)
&&//&&val&value&=&3
&&//&&val&result&=&value&match&{
&&//&&&&case&i&if&i&==&1&=&&"one"
&&//&&&&case&i&if&i&==&2&=&&"two"
&&//&&&&case&_&=&&"some&other&number"
&&//&&println("result&of&match&is&:&"&+&result)
&&//&&def&t(obj:&Any)&=&obj&match&{
&&//&&&&case&x:&Int&=&&println("Int")
&&//&&&&case&s:&String&=&&println("String")
&&//&&&&case&_&=&&println("unknown&type")
&&//&t("1")
&&//&&t(1L)
&&//&&val&macTalk&=&Book("MacTalk",&"CJQ")
&&//&&macTalk&match&{
&&//&&&&case&Book(name,&author)&=&&println("&this&is&a&book")
&&//&&&&case&_&=&&println("unknown")
&&//&&val&l&=&List(1,&2,&3,&4,&5,&6,&7,&8,&9)
&&//&&val&newList&=&l.map((x:&Int)&=&&2&*&x)
&&//&&val&newList2&=&l.map((x)&=&&2&*&x)
&&//&&val&newList3&=&l.map(x&=&&2&*&x)
&&//&&println(newList)
&&//&&println(newList2)
&&//&&println(newList3)
&&//&&val&newList&=&l.map(2&*&_)
&&//&&println(newList)
&&var&l&=&List(1,&2,&3,&4,&5,&6);
&&var&s&=&Set(1,&2,&3,&4,&5,&6);
&&val&l1&=&List(1,&2,&3,&4,&5)
&&val&s1&=&Set(1,&2,&3);
&&val&hostPort&=&("localhost",&"8080")
&&//访问数组
&&println(hostPort._1)
}结果：localhostpackage&cn.chinahadoop.scala
class&Basic5&{
//默认为val
case&class&Book(name:&String,&author:&String)
object&Basic5&extends&App&{
&&//&&val&value&=&3
&&//&&//match是有返回值的
&&//&&val&result&=&value&match&{
&&//&&&&case&1&=&&"one"
&&//&&&&case&2&=&&"two"
&&//&&&&case&_&=&&"some&other&number"
&&//&&println("result&of&match&&is&:"&+&result)
&&//&&val&value&=&3
&&//&&val&result&=&value&match&{
&&//&&&&case&i&if&i&==&1&=&&"one"
&&//&&&&case&i&if&i&==&2&=&&"two"
&&//&&&&case&_&=&&"some&other&number"
&&//&&println("result&of&match&is&:&"&+&result)
&&//&&def&t(obj:&Any)&=&obj&match&{
&&//&&&&case&x:&Int&=&&println("Int")
&&//&&&&case&s:&String&=&&println("String")
&&//&&&&case&_&=&&println("unknown&type")
&&//&t("1")
&&//&&t(1L)
&&//&&val&macTalk&=&Book("MacTalk",&"CJQ")
&&//&&macTalk&match&{
&&//&&&&case&Book(name,&author)&=&&println("&this&is&a&book")
&&//&&&&case&_&=&&println("unknown")
&&//&&val&l&=&List(1,&2,&3,&4,&5,&6,&7,&8,&9)
&&//&&val&newList&=&l.map((x:&Int)&=&&2&*&x)
&&//&&val&newList2&=&l.map((x)&=&&2&*&x)
&&//&&val&newList3&=&l.map(x&=&&2&*&x)
&&//&&println(newList)
&&//&&println(newList2)
&&//&&println(newList3)
&&//&&val&newList&=&l.map(2&*&_)
&&//&&println(newList)
&&var&l&=&List(1,&2,&3,&4,&5,&6);
&&var&s&=&Set(1,&2,&3,&4,&5,&6);
&&val&l1&=&List(1,&2,&3,&4,&5)
&&val&s1&=&Set(1,&2,&3);
&&val&hostPort&=&("localhost",&"8080")
&&//访问数组
&&println(hostPort._1)
&&println("a"&-&&"s1")
}结果：localhost
(a,s1)用"a" -& "b" 创建了一个字符串(a,s1)的字符数组。package&cn.chinahadoop.scala
class&Basic5&{
//默认为val
case&class&Book(name:&String,&author:&String)
object&Basic5&extends&App&{
&&//&&val&value&=&3
&&//&&//match是有返回值的
&&//&&val&result&=&value&match&{
&&//&&&&case&1&=&&"one"
&&//&&&&case&2&=&&"two"
&&//&&&&case&_&=&&"some&other&number"
&&//&&println("result&of&match&&is&:"&+&result)
&&//&&val&value&=&3
&&//&&val&result&=&value&match&{
&&//&&&&case&i&if&i&==&1&=&&"one"
&&//&&&&case&i&if&i&==&2&=&&"two"
&&//&&&&case&_&=&&"some&other&number"
&&//&&println("result&of&match&is&:&"&+&result)
&&//&&def&t(obj:&Any)&=&obj&match&{
&&//&&&&case&x:&Int&=&&println("Int")
&&//&&&&case&s:&String&=&&println("String")
&&//&&&&case&_&=&&println("unknown&type")
&&//&t("1")
&&//&&t(1L)
&&//&&val&macTalk&=&Book("MacTalk",&"CJQ")
&&//&&macTalk&match&{
&&//&&&&case&Book(name,&author)&=&&println("&this&is&a&book")
&&//&&&&case&_&=&&println("unknown")
&&//&&val&l&=&List(1,&2,&3,&4,&5,&6,&7,&8,&9)
&&//&&val&newList&=&l.map((x:&Int)&=&&2&*&x)
&&//&&val&newList2&=&l.map((x)&=&&2&*&x)
&&//&&val&newList3&=&l.map(x&=&&2&*&x)
&&//&&println(newList)
&&//&&println(newList2)
&&//&&println(newList3)
&&//&&val&newList&=&l.map(2&*&_)
&&//&&println(newList)
&&//&&var&l&=&List(1,&2,&3,&4,&5,&6);
&&//&&var&s&=&Set(1,&2,&3,&4,&5,&6);
&&//&&val&l1&=&List(1,&2,&3,&4,&5)
&&//&&val&s1&=&Set(1,&2,&3);
&&//&&val&hostPort&=&("localhost",&"8080")
&&//访问数组
&&//&&println(hostPort._1)
&&//&&println("a"&-&&"s1")
&&val&m1&=&Map("a"&-&&"b");
&&println(m1)
}结果：Map(a&-&&b)650) this.width=650;" src="/wyfs02/M02/29/A3/wKioL1N96puDDQQPAAA-rqkopCs609.png" title="_201246.PNG" alt="wKioL1N96puDDQQPAAA-rqkopCs609.png" />map的初始化。package&cn.chinahadoop.scala
class&Basic5&{
//默认为val
case&class&Book(name:&String,&author:&String)
object&Basic5&extends&App&{
&&//&&val&value&=&3
&&//&&//match是有返回值的
&&//&&val&result&=&value&match&{
&&//&&&&case&1&=&&"one"
&&//&&&&case&2&=&&"two"
&&//&&&&case&_&=&&"some&other&number"
&&//&&println("result&of&match&&is&:"&+&result)
&&//&&val&value&=&3
&&//&&val&result&=&value&match&{
&&//&&&&case&i&if&i&==&1&=&&"one"
&&//&&&&case&i&if&i&==&2&=&&"two"
&&//&&&&case&_&=&&"some&other&number"
&&//&&println("result&of&match&is&:&"&+&result)
&&//&&def&t(obj:&Any)&=&obj&match&{
&&//&&&&case&x:&Int&=&&println("Int")
&&//&&&&case&s:&String&=&&println("String")
&&//&&&&case&_&=&&println("unknown&type")
&&//&t("1")
&&//&&t(1L)
&&//&&val&macTalk&=&Book("MacTalk",&"CJQ")
&&//&&macTalk&match&{
&&//&&&&case&Book(name,&author)&=&&println("&this&is&a&book")
&&//&&&&case&_&=&&println("unknown")
&&//&&val&l&=&List(1,&2,&3,&4,&5,&6,&7,&8,&9)
&&//&&val&newList&=&l.map((x:&Int)&=&&2&*&x)
&&//&&val&newList2&=&l.map((x)&=&&2&*&x)
&&//&&val&newList3&=&l.map(x&=&&2&*&x)
&&//&&println(newList)
&&//&&println(newList2)
&&//&&println(newList3)
&&//&&val&newList&=&l.map(2&*&_)
&&//&&println(newList)
&&//&&var&l&=&List(1,&2,&3,&4,&5,&6);
&&//&&var&s&=&Set(1,&2,&3,&4,&5,&6);
&&//&&val&l1&=&List(1,&2,&3,&4,&5)
&&//&&val&s1&=&Set(1,&2,&3);
&&//&&val&hostPort&=&("localhost",&"8080")
&&//访问数组
&&//&&println(hostPort._1)
&&//&&println("a"&-&&"s1")
&&val&m1&=&Map("a"&-&&"b",&"c"&-&&"d");
&&println(m1)
}结果：Map(a&-&&b,&c&-&&d)集合操作&&&&foreach（类似于map，但是没有返回值）&&&&map（迭代）&&&&filter（过滤）&&&&zip（集合）&&&&partition(列表过滤)&&&&flatten(扁平化)&&&&flatMap(map+flatten)val&m1&=&Map("a"&-&&"b",&"c"&-&&"d",&"e"&-&&"f",&"c"&-&&"f");
&&println(m1("c"))结果：f在java中key是不能有重复的，但在scala中可以，但如果key重复的话后面的值会覆盖前面的值。val&m1&=&Map("a"&-&&"b",&"c"&-&&"d",&"e"&-&&"f",&"c"&-&&"f");
&&//&println(m1("c"))
&&println(m1.getOrElse("c",&3));
&&println(m1.getOrElse("cd",&4));结果：f
4&val&l&=&List('c',&'d',&'e',&'s',&'e',&'s',&'e',&'s',&'f',&'d',&'f',&'s',&'w')
&&println(l.take(1))结果：List(c)foreach用法val&m1&=&Map("a"&-&&"b",&"c"&-&&"d",&"e"&-&&"f",&"c"&-&&"f");
&&val&l&=&List('c',&'d',&'e',&'s',&'e',&'s',&'e',&'s',&'f',&'d',&'f',&'s',&'w')
&&val&r1=List(1,23,4,52,2,3)
&&println(l.take(1))
&&println(r1.map(3&*&_))
&&println(r1)结果：List(c)
List(3,&69,&12,&156,&6,&9)
List(1,&23,&4,&52,&2,&3)foreach没有返回值&&val&r1&=&List(1,&23,&4,&52,&2,&3)&
&&println(r1.foreach(3&*&_))结果：()filter的用法 （过滤）val&r1&=&List(1,&23,&4,&52,&2,&3)
&&println(r1.filter(x&=&&x&%&2&==&0))结果：List(4,&52,&2)zip，聚合，对数值进行匹配val&a&=&List(1,&2,&3)
&&val&b&=&List(4,&5,&6)
&&println(a.zip(b))结果：List((1,4),&(2,5),&(3,6))如果没有数值对它进行匹配，就会省略val&a&=&List(1,&2,&3)
&&val&b&=&List(4,&5,&6,7)
&&println(a.zip(b))结果：List((1,4),&(2,5),&(3,6))partiton列表分割&val&l&=&List(1,&2,&3,&4,&5,&6,&7,&8)
&&println(l.partition(_&%&2&==&0))结果：(List(2,&4,&6,&8),List(1,&3,&5,&7))flatten（扁平化）&val&l=List(List("a","b"),List("c","d")).flatten
&&println(l)结果：List(a,&b,&c,&d)flatMap(map+flatten)&val&l&=&List(List(1,&2),&List(3,&4))
&&println(l.flatMap(x&=&&x.map(_&*&2)))结果：List(2,&4,&6,&8)spark官网中 file = spark.textFile("hdfs://...")&file.flatMap(lambda line: line.split())&&&&.map(lambda word: (word, 1))&&&&.reduceByKey(lambda a, b: a+b)泛型&&&&泛型类&&&&&class Pair[T,S](val first: T, val second: S)&&&&泛型方法&&&&def compute[T](list:List[T])=....隐式转换&&&&&&&&位于源目标类型的伴生对象中的隐式函数&&&&位于当前作用域可以以单个标识符指代的隐匿函数&&&&隐式参数&&&&隐式类(scala 2.10)隐式转换的关键字implicitpackage&cn.chinahadoop.scala
class&Basic6&{
class&RichA(a:&A)&{
&&def&rich&{
&&&&println("rich&......")
object&Basic6&extends&App&{
&&implicit&def&a_RichA(a:&A)&=&new&RichA(a)
&&val&a&=&new&A
rich&......隐式参数&def&testParam(implicit&name:&String)&{
&&&&println(name)
&&implicit&val&name&=&"implicit!!!"
&&testParam结果：implicit!!!def&testParam(implicit&name:&String)&{
&&&&println(name)
&&implicit&val&name&=&"implicit!!!"
&&testParam("chsl")结果：chsl隐式类&implicit&class&Calculator(x:&Int)&{
&&&&def&add(a:&Int):&Int&=&a&+&1
&&print(1.add(1))结果：2本文出自 “” 博客，谢绝转载！
了这篇文章
类别：┆阅读(0)┆评论(0)}