BT

如何利用碎片时间提升技术认知与能力? 点击获取答案

向Java开发者介绍Scala

| 作者 Thomas Alexandre 关注 0 他的粉丝 ,译者 王恒涛 关注 0 他的粉丝 发布于 2011年9月27日. 估计阅读时间: 33 分钟 | QCon上海2018 关注大数据平台技术选型、搭建、系统迁移和优化的经验。

Scala结合了面向对象编程与函数编程思想,使用一种能够完全兼容Java、可以运行在Java虚拟机上的、简洁的语法。对于函数编程风格的支持,尤其是对于Lambda表达式的支持,能够有助于减少必须要编写的逻辑无关固定代码,也许让它可以更简单的关注要面对的任务本身,而相对的Java中对Lamdba表达式的支持要到预定于2012年发布的JavaSE8才会实现。本文就是对于Scala介绍。

作为第一步,先安装好最新的Scala发布包Typesafe stack,打开命令行窗口,键入“scala”:这会启动REPL(读入-运算 输出 循环)交互式编码环境。然后你就可以写下你的第一行Scala代码:

scala> val columbus : Int = 1492
columbus: Int = 1492

我们刚刚声明了一个类型为Int的变量,初始值为1492,就像我们在Java里用语句Int columbus = 1492;所做的一样。除了把类型放在变量之后这样一种反向的声明方式之外,Scala在这里所表现出的不同是使用“val”来显性地把变量声明为不可变。如果我们想要修改这个变量:

scala> columbus = 1500
 <console>:8: error: reassignment to val
   columbus = 1500
          ^

请注意错误消息精确地指出了错误位于行的哪个位置。再尝试声明这个变量,但这一次用“var”,让其可变更。这样编译器拥有足够的智能来推断出1492是一个整数,你也就不需要指定类型了:

 scala> var columbus = 1492
 columbus: Int = 1492

scala> columbus = 1500  columbus: Int = 1500

接下来,我们来定义一个类:

scala> case class Employee( name:String="guest", age:Int=30, company:String =  "DevCode" )
 defined class Employee 

我们定义了一个类,名为Employee,有三个不可变更的字段:name、age和company,各自有自己的缺省值。关键字“case”相当于Java里的switch语句,只不过要更为灵活。它说明该类具有模式匹配的额外机制,以及其他一些特性,包括用来创建实例的工厂方法(不需要使用“new”关键字来构造),同样的也不需要创建缺省的getter方法。与Java中不同的是,变量缺省下的访问控制是public(而不是protected),而Scala为公开变量创建一个getter方法,并命名为变量名。如果你愿意,你也可以把字段定义成可变且/或私有(private)的,只需要在参数之前使用“var”(例如:case class Person(private var name:String))。

我们再来用不同方式创建一些实例,看看其他的特性,像是命名参数和缺省参数(从Scala2.8开始引入):

scala> val guest = Employee()
 guest: Employee = Employee(guest,30,DevCode)

scala> val guestAge = guest.age // (age变量的缺省getter方法)  guestAge: Int = 300
scala> val anna = Employee("Anna")  anna: Employee = Employee(Anna,30,DevCode)
scala> val thomas = Employee("Thomas",41)  thomas: Employee = Employee(Thomas,41,DevCode)
scala> val luke = Employee("Luke", company="LucasArt")  luke: Employee = Employee(Luke,30,LucasArt)
scala> val yoda = luke.copy("Yoda", age=800)  yoda: Employee = Employee(Yoda,800,LucasArt)

不过,下面的写法

 
scala> val darth = Employee("Darth", "DevCode")
 <console>:9: error: type mismatch;
 found : java.lang.String("DevCode")
 required: Int
 Error occurred in an application involving default arguments.
     val darth = Employee("Darth", "DevCode")
                     ^

是行不通的(可不是因为Darth不是DevCode的雇员!),这是由于构造函数在这个位置需要age作为参数,因为函数参数没有显性地进行命名。

现在我们再来看集合,这才是真正让人兴奋的地方。

有了泛型(Java5以上),Java可以遍历一个——比方说整数型列表,用下面这样的代码:

List<Integer> numbers = new arrayList<Integer>();
    numbers.add(1);
    numbers.add(2);
    numbers.add(3);
    for(Integer n:numbers) {
        System.out.println("Number "+n);
}

运行的结果是

Number 1
Number 2
Number 3

Scala对于可变集合和不可变集合进行了系统性地区别处理,不过鼓励使用不可变集合,也因此在缺省情况下创建不可变集合。这些集合是通过模拟的方式实现添加、更新和删除操作,在这些操作中,不是修改集合,而是返回新的集合。

与前面的Java代码等价的Scala代码可能像下面这样:

scala> val numbers = List(1,2,3)
 numbers: List[Int] = List(1, 2, 3)

scala> for (n <- numbers) println("Number "+n)  Number 1  Number 2  Number 3

这里的“for”循环语法结构非常接近于Java的命令式编程风格。在Scala(以及Java虚拟机上其他很多语言如:Groovy、JRuby或JPython)里还有另外一种方式来实现上面的逻辑。这种方式使用一种更加偏向函数编程的风格,引入了Lambda表达式(有时也称为闭包——closure)。简单地说,Lambda表达式就是你可以拿来当作参数传递的函数。这些函数使用参数作为输入(在我们的例子中就是“n”整型变量),返回语句作为函数体的最终语句。他们的形式如下

functionName { input =>
    body
}

scala> numbers.foreach { n:Int =>     // 按回车键继续下一行 
    | println("Number "+n)  
    | }  Number 1  Number 2  Number 3

上面的例子中,函数体只有一条语句(println……),返回的是单位(Unit,也就是“空结果”),也就是大致相当于Java中的void,不过有一点不同的是——void是不返回任何结果的。

除了只打印出我们的数值列表以外,应该说我们更想做的是处理和变换这些元素,这时我们需要调用方法来生成结果列表,以便后面接着使用。让我们尝试一些例子:

scala> val reversedList = numbers.reverse
 reversedList: List[Int] = List(3, 2, 1)

scala> val numbersLessThan3 = numbers.filter { n => n < 3 }  numbersLessThan3: List[Int] = List(1, 2)
scala> val oddNumbers = numbers.filterNot { n => n % 2 == 0 }  oddNumbers: List[Int] = List(1, 3)
scala> val higherNumbers = numbers.map { n => n + 10 }  higherNumbers: List[Int] = List(11, 12, 13)

最后的这一个变换“map”非常有用,它对列表的每一个元素应用闭包,结果是一个同样大小的、包含了每个变换后元素的列表。

我们在这里还想介绍最后的一个方法,就是“foldLeft”方法,它把状态从一个元素传播到另一个元素。比如说,要算出一个列表里所有元素的和,你需要累加它们,并在切换元素的时候保存中间的计数:

scala> val sumOfNumbers = numbers.foldLeft(0) { (total,element) =>
    | total + element
    | }
 sumOfNumbers: Int = 6

作为第一个变量传递给foldLeft的值0是初始值(也就是说在把函数用到第一个列表元素的时候total=0)。(total,element)代表了一个Tuple2,在Scala里这是一个二元组(就像要表示三维空间坐标,经常要用到Tuple3(x,y,z)等等)。注意在合计时,Scala的编程接口实际上提供了一个“sum”方法,这样上一条语句就可以写成:

scala> val sumOfNumbers = numbers.sum
 sumOfNumbers: Int = 6

还有许多其他的类似的集合变换方法,你可以参照scaladoc API。你也可以把这些方法组合起来(例如:numbers.reverse.filter……),让代码更加简洁,不过这样会影响可读性。

最后,{ n => n + 10 }还可以简单地写成(_ + 10),也就是说如果输入参数只是用于你调用的方法,则不需要声明它;在我们的例子里,“n”被称为匿名变量,因为你可以把它用任何形式来代替,比如说“x”或者“number”,而下划线则表示一处需要用你的列表的每个元素来填补的空白。(与“_”的功能类似,Groovy保留了关键字“it”,而Python则使用的是“self”)。

scala> val higherNumbers = numbers.map(_+10)
 higherNumbers: List[Int] = List(11, 12, 13) 

在介绍了对整数的基本处理后,我们可以迈入下一个阶段,看看复杂对象集合的变换,例如使用我们上面所定义的Employee类:

scala> val allEmployees = List(luke,anna,guest,yoda,thomas)
 allEmployees: List[Employee] = List(Employee(Luke,30,LucasArt),  Employee(Anna,30,DevCode), Employee(guest,30,DevCode),  Employee(Yoda,800,LucasArt), Employee(Thomas,41,DevCode))

从这个五个元素的列表里,我们可以应用一个条件来过滤出应用匿名方法后返回值为True的雇员,这样就得到了——比方说属于DevCode的雇员:

scala> val devcodeEmployees = allEmployees.filter { _.company == "DevCode" }
 devcodeEmployees: List[Employee] = List(Employee(Anna,30,DevCode),  Employee(guest,30,DevCode), Employee(Thomas,41,DevCode))

scala> val oldEmployees = allEmployees.filter(_.age > 100).map(_.name)  oldEmployees: List[String] = List(Yoda)

假设我们手头的allEmployees集合是我们使用SQL查询获得的结果集,查询语句可能类似于“SELECT * FROM employees WHERE company = ‘DevCode’ ”。现在我们可以把List[Employee]变换到以company名称作为键、属于该公司的所有员工的列表作为值的Map类型,这样就可以把雇员按company来排序:

 scala> val sortedEmployees = allEmployees.groupBy(_.company)
 sortedEmployees: scala.collection.immutable.Map[String,List[Employee]] = Map(DevCode - > List(Employee(Anna,30,DevCode), Employee(guest,30,DevCode),  Employee(Thomas,41,DevCode)), LucasArt -> List(Employee(Luke,30,LucasArt),  Employee(Yoda,800,LucasArt)))

每一个列表已经作为一个值存入了(键——值)哈希表,为了示范如何进一步处理这些列表,可以设想我们需要计算每个公司的雇员平均年龄。

这具体意味着我们必须要计算每个列表的每个雇员的的“age”字段的和,然后除以该列表中雇员的数量。让我们先计算一下DevCode:

scala> devcodeEmployees
 res4: List[Employee] = List(Employee(Anna,30,DevCode), Employee(guest,30,DevCode),  Employee(Thomas,41,DevCode))

scala> val devcodeAges = devcodeEmployees.map(_.age)  devcodeAges: List[Int] = List(30, 30, 41)
scala> val devcodeAverageAge = devcodeAges.sum / devcodeAges.size  devcodeAverageAge: Int = 33

回到我们的Map (key:String ->value:List[Employee]),下面是个更加一般性的例子。我们现在可以归并并计算每个公司的平均年龄,要做的只是写几行代码:

 
scala> val averageAgeByCompany = sortedEmployees.map{ case(key,value)=>
    | value(0).copy(name="average",age=(value.map(_.age).sum)/value.size)}
 averageAgeByCompany: scala.collection.immutable.Iterable[Employee] =  List(Employee(average,33,DevCode), Employee(average,415,LucasArt))

这里的“case(key,value)”说明了Scala提供的模式匹配机制是多么强大。请参考Scala的文档来获取更多的信息。

到这里我们的任务就完成了。我们实现的是一个简单的Map-Reduce算法。由于每个公司雇员的归并是完全独立于其他公司,这个算法非常直观地实现了并行计算。

在后面的附录里给出了此算法的等价的实现,分为Java版本和Scala版本。

参考

The typesafe stack.

附录

Map Reduce: Java

public class Employee {

    final String name;
    final Integer age;
    final String company;

    public Employee(String name, Integer age, String company) {
        this.name = name == null ? "guest" : name;
        this.age = age == null ? 30 : age;
        this.company = company == null ? "DevCode" : company;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getCompany() {
        return company;
    }

    @Override
    public String toString() {
        return "Employee [name=" + name + ", age=" + age + ",
               company="
               + company + "]";
    }
}

class Builder {
    String name, company;
    Integer age;

    Builder(String name) {
        this.name = name;

    }

    Employee build() {
        return new Employee(name, age, company);
    }

    Builder age(Integer age) {
        this.age = age;
        return this;
    }

    Builder company(String company) {
        this.company = company;
        return this;
    }
}

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import com.google.common.base.Function;
import com.google.common.collect.ImmutableListMultimap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Multimaps;

public class MapReduce {

    public static final void main(String[] args) {
        Employee guest = new Builder("Guest").build();
        Employee anna = new Builder("Anna").build();
        Employee thomas = new Builder("Thomas").age(41).build();
        Employee luke = new
            Builder("Luke").company("LucasArt").build();
        Employee yoda = new
            Builder("Yoda").age(800).company("LucasArt").build();

        Collection<Employee> employees = new ArrayList<Employee>();
        employees.add(guest);
        employees.add(anna);
        employees.add(thomas);
        employees.add(luke);
        employees.add(yoda);

        ImmutableListMultimap<String, Employee>
            personsGroupByCompany = Multimaps.index(employees, new Function<Employee,String>() {

                public String apply(Employee person) {
                   return person.getCompany();
                 }

              });

        ImmutableSet<String> companyNamesFromMap =
            personsGroupByCompany.keySet();

        List<Employee> averageAgeByCompany = new
            ArrayList<Employee>();

        for(String company: companyNamesFromMap) {
             List<Employee> employeesForThisCompany =
                personsGroupByCompany.get(company);
             int sum = 0;
             for(Employee employee: employeesForThisCompany) {
                 sum+= employee.getAge();
             }
             averageAgeByCompany.add(new
                Employee("average",sum/employeesForThisCompany.size(),company));
     }
     System.out.println("Result: "+averageAgeByCompany);

    }
}

MapReduce.scala:

case class Employee(name: String = "guest", age: Int = 30, company: String = "DevCode")

    object MapReduce {
        def main(args: Array[String]): Unit = {

        val guest = Employee()
        val anna = Employee("Anna")
        val thomas = Employee("Thomas", 41)
        val luke = Employee("Luke", company = "LucasArt")
        val yoda = luke.copy("Yoda", age = 800)

        val allEmployees = List(luke, anna, guest, yoda, thomas)
        val sortedEmployees = allEmployees.groupBy(_.company)
        val averageAgeByCompany = sortedEmployees.map { case (key, value) =>
            value(0).copy(name = "average", age = (value.map(_.age).sum) / value.size)
      }
        println("Result: "+averageAgeByCompany)
    }
}

关于作者

Thomas Alexandre是DevCode的高级咨询顾问,专注于Java和Scala软件开发。他热爱技术,热衷于分享知识,永远在寻求方法、采用新的开源软件和标准来实现更加有效的编程。在十四年的Java开发经验之外,过去几年他集中精力在新的编程语言和Web框架上,例如Groovy/Grails和Scala/Lift。Thomas从法国里尔大学获得了计算机科学博士学位,在卡耐基梅隆大学度过了两年的博士后研究生涯,研究方向是安全和电子商务。

 

查看英文原文: An Introduction to Scala for Java Developers


给InfoQ中文站投稿或者参与内容翻译工作,请邮件至editors@cn.infoq.com。也欢迎大家加入到InfoQ中文站用户讨论组中与我们的编辑和其他读者朋友交流。

评价本文

专业度
风格

您好,朋友!

您需要 注册一个InfoQ账号 或者 才能进行评论。在您完成注册后还需要进行一些设置。

获得来自InfoQ的更多体验。

告诉我们您的想法

允许的HTML标签: a,b,br,blockquote,i,li,pre,u,ul,p

当有人回复此评论时请E-mail通知我

Java是码农的语言 by Jeffrey Zhao

这里我说的“码农”是指时间不值钱的程序员。用Java写程序太花时间了,程序员有了一个想法以后,还要花很多心思把它变成代码,这个很令人不爽的,所以大伙还是努力推广表达能力强大的语言吧。

Re: Java是码农的语言 by deepnighttwo deepnighttwo

一句道理上不全错的话,表达的时候也应该注意。开发效率不高就说开发效率不高,扯用的人有意思吗?难道C的开发效率高?排名前两名的语言开发效率都不如流行的脚本,你如果连其中原因都看不透,白混这么多年了。

Re: Java是码农的语言 by Chane Michael

首先,我承认java语言features太少,但是反过来说,很多表达能力不高的语言,类库之丰富,可不是那些表达能力高的语言可以比的。很多时候,很多程序员只是在用表达能力高的语言,实现表达能力差的语言早就实现的功能,在这个意义上,这些人也是代码民工

Re: Java是码农的语言 by Lin hadix

首先,我承认java语言features太少,但是反过来说,很多表达能力不高的语言,类库之丰富,可不是那些表达能力高的语言可以比的。很多时候,很多程序员只是在用表达能力高的语言,实现表达能力差的语言早就实现的功能,在这个意义上,这些人也是代码民工


现今的变成环境已经发生了很多变化,Java在一定程度上已经不再适合了,比如并行计算,Java无法实现简单的MapReduce.这导致所有的Java类库都无法简单的处理并发计算,从hadoop的API中可以看出这一点.闭包语法为编程带来了很多便利,使代码更具表达力.Java有庞大的类库,如果能加入类型推断,和闭包.相信这些类库的API都可以得到进化.没有一件工具可以完美解决所有问题,只有用合适的工具做合适的事.

Re: Java是码农的语言 by wang dafee

我知识浅薄,想请教原因是什么,简单解释下即可,感谢。

Re: Java是码农的语言 by wang dafee

一句道理上不全错的话,表达的时候也应该注意。开发效率不高就说开发效率不高,扯用的人有意思吗?难道C的开发效率高?排名前两名的语言开发效率都不如流行的脚本,你如果连其中原因都看不透,白混这么多年了。

我知识浅薄,想请教原因是什么,简单解释下即可,感谢。

允许的HTML标签: a,b,br,blockquote,i,li,pre,u,ul,p

当有人回复此评论时请E-mail通知我

允许的HTML标签: a,b,br,blockquote,i,li,pre,u,ul,p

当有人回复此评论时请E-mail通知我

6 讨论

登陆InfoQ,与你最关心的话题互动。


找回密码....

Follow

关注你最喜爱的话题和作者

快速浏览网站内你所感兴趣话题的精选内容。

Like

内容自由定制

选择想要阅读的主题和喜爱的作者定制自己的新闻源。

Notifications

获取更新

设置通知机制以获取内容更新对您而言是否重要

BT