Scala编程实例指南：英文高清版

需积分: 9 62 浏览量更新于2024-07-18 收藏 10.85MB PDF 举报

"Scala Cookbook" 是一本由 Alvin Alexander 编写的英文高清版书籍，适合 Scala 入门者，包含许多经典实例，旨在帮助读者更好地理解和掌握 Scala 语言。该书由 O'Reilly Media 出版，并提及可用于教育、商业或销售推广用途。此外，该书的在线版本也可在 Safari Books Online 上找到。这本书由 Courtney Nash 担任编辑，Rachel Steely 负责生产编辑，Kim Cofer 担任校对编辑，Linley Dolby 进行校对，Ellen Troutman 编制索引，封面设计由 Karen Montgomery 完成，内页设计由 David Futato 负责，插图由 Rebecca Demarest 制作。第一版于 2013 年 8 月发布，并可在 O'Reilly 的错误报告页面查看具体的修订历史。《Scala Cookbook》涵盖了 Scala 语言的核心概念和实用技巧，是学习和提升 Scala 技能的重要资源。作为大数据领域的常用语言，Scala 因其强大的函数式编程特性、与 Java 兼容性以及在 Apache Spark 等大数据框架中的应用而备受关注。本书可能包括以下关键知识点： 1. **基础语法**：介绍 Scala 的基本语法结构，如变量声明、数据类型、控制流语句（如条件判断、循环）以及函数定义等。 2. **面向对象编程**：探讨 Scala 的类、对象、继承和多态性等面向对象特性，同时展示如何在 Scala 中实现模块化设计。 3. **函数式编程**：讲解 Scala 的高阶函数、闭包、柯里化、模式匹配、不可变数据结构等函数式编程概念，帮助读者理解和运用函数式编程思维。 4. **集合框架**：深入解析 Scala 集合库，包括 List、Set、Map 等数据结构，以及操作它们的高效方法。 5. **类型系统**：讨论 Scala 的类型系统，包括隐式转换、类型推断和泛型等高级特性。 6. **并发编程**：介绍 Scala 支持的并发和并行编程模型，如 Actors、Futures 和 Promises，以及 Akka 框架的使用。 7. **案例研究**：通过实际案例，展示如何在大数据处理、Web 开发、分布式系统等场景中使用 Scala。 8. **与其他技术的整合**：讲解 Scala 如何与 Java、JVM 库以及大数据工具（如 Apache Hadoop 和 Spark）集成。 9. **测试和调试**：提供关于如何在 Scala 项目中进行单元测试和集成测试，以及使用 ScalaTest 等测试框架的方法。 10. **最佳实践**：分享编写可维护、可扩展的 Scala 代码的最佳实践和设计模式。《Scala Cookbook》是一本全面的 Scala 学习资源，无论你是初学者还是经验丰富的开发者，都能从中找到提高技能的实用示例和指导。通过学习本书，你将能够熟练地运用 Scala 解决实际问题，特别是在大数据处理领域。

In my opinion, Scala is not a good language for teaching a Programming 101 class.

Instead, it’s a power language created for the professional programmer. Don’t let that

scare you, though. If you were my own brother and about to start a new project and

could choose any programming language available, without hesitation I’d say, “Use

Scala.”

Here are a few more nuggets about Scala:

•

It’s a modern programming language created by Martin Odersky (the father of

javac), influenced by Java, Ruby, Smalltalk, ML, Haskell, Erlang, and others.

•

It’s a pure object-oriented programming (OOP) language. Every variable is an ob‐

ject, and every “operator” is a method.

• It’s also a functional programming (FP) language, so you can pass functions around

as variables. You can write your code using OOP, FP, or both.

• Scala code runs on the JVM and lets you use the wealth of Java libraries that have

been developed over the years.

• You can be productive on Day 1, but the language is deep, so as you go along you’ll

keep learning and finding newer, better ways to write code. Scala will change the

way you think about programming—and that’s a good thing.

Of all of Scala’s benefits, what I like best is that it lets you write concise, readable code.

The time a programmer spends reading code compared to the time spent writing code

is said to be at least a 10:1 ratio, so writing code that’s concise and readable is a big deal.

Because Scala has these attributes, programmers say that it’s expressive.

Solutions

I’ve always bought O’Reilly cookbooks for the solutions, and that’s what this book is

about: solving problems.

When using a cookbook, I usually think, “I have this problem, I need to iterate over the

elements in an Array, what’s the best way to do that?” I like to look at the table of contents,

find a recipe, implement the solution, and move on. I tried to write each recipe with

this use case in mind.

However, with a modern language like Scala, it may end up that I phrased my question

wrong. Because of my prior programming experience I may have thought, “I need to

iterate over the elements in an Array,” but in reality my deeper intent was to loop over

those elements for a reason, such as to transform them into a new collection. So it’s nice

when a recipe says, “Hey, I know you’re here to read about how to loop over the elements

in an Array, here’s how you do that”:

for (i <- Array(1,2,3)) println(i)

xiv | Preface

“But, if what you’re really trying to do is transform those elements into a new collection,

what you want is a for/yield expression or map method”:

// for/yield

scala> for (i <- Array(1,2,3)) yield i * 2

res0: Array[Int] = Array(2, 4, 6)

// map

scala> Array(1,2,3).map(_ * 2)

res1: Array[Int] = Array(2, 4, 6)

(More on that _ character shortly.)

To create the list of problems and solutions, I followed the “Eat your own dog food”

philosophy. The recipes come from my own experience of creating Scala scripts, web

applications, web services, Swing applications, and actor-based systems. As I developed

the applications I needed, I encountered problems like these:

• Scala files tend to be very small; what’s the proper way to organize an application?

• It looks like SBT is the best build tool for Scala, but it’s different than Ant or Maven;

how do I compile and package applications, and work with dependencies?

• Constructors are really different than Java; how do I create them? What code is

generated when I declare constructor parameters and class fields?

•

Actors are cool; how do I write a complete actor-based application?

•

What, I shouldn’t use null values anymore? Why not? How do I code without them?

•

I can pass a function around like any other variable? How do I do that, and what’s

the benefit?

•

Why are there so many collections classes, and why does each collection class have

so many methods?

•

I have all of this legacy Java code; can I still use it in Scala? If so, how?

•

I’m starting to grok this. Now I need to know, what are the top five or ten “best

practices” of writing Scala code?

Truthfully, I fell fast in love with everything about Scala except for one thing: the col‐

lections library seemed large and intimidating. I really enjoyed using Scala so I kept

using the language, but whenever I needed a collection, I used a trusty old Java collection.

Then one day I got up the courage to dive into the collections library. I thought I’d hate

it, but after struggling with it for a while, I suddenly “got” it. The light bulb went on over

my head, and I suddenly understood not only the collections, but several other concepts

I had been struggling with as well. I realized the collections library writers aren’t crazy;

they’re brilliant.

Preface | xv

Once I understood the collections library, I quit writing so many for loops, and started

using collection methods like filter, foreach, and map. They made coding easier, and

made my code more concise. These days I can’t imagine a better way to write code like

this:

// filter the items in a list

scala> val nums = List(1,2,3,4,5).filter(_ < 4)

nums: List[Int] = List(1, 2, 3)

The _ wildcard character is discussed in several recipes, but as you can infer from that

example, it’s a placeholder for each element in the collection. The filter method loops

through each element in the list, calling your _ < 4 function on each iteration. That

Scala one-liner is the equivalent of this Java code:

Integer[] intArray = {1,2,3,4,5};

List<Integer> nums = Arrays.asList(intArray);

List<Integer> filteredNums = new LinkedList<Integer>();

for (int n: nums) {

if (n < 4) filteredNums.add(n);

}

The next example takes this a step further. It filters the elements as in the previous

example, and then multiplies each element by the number 2 using the map method:

// filter the items, then double them

scala> val nums = List(1,2,3,4,5).filter(_ < 4).map(_ * 2)

nums: List[Int] = List(2, 4, 6)

If you think about how much code would be required to write this expression in another

language, I think you’ll agree that Scala is expressive.

(If you’re new to Scala, examples like this are broken down into smaller chunks in the

recipes.)

Audience

This book is intended for programmers who want to be able to quickly find solutions

to problems they’ll encounter when using Scala and its libraries and tools. I hope it will

also be a good tool for developers who want to learn Scala. I’m a big believer in “learning

by example,” and this book is chock full of examples.

I generally assume that you have some experience with another programming language

like C, C++, Java, Ruby, C#, PHP, Python, or similar. My own experience is with those

languages, so I’m sure my writing is influenced by that background.

Another way to describe the audience for this book involves looking at different levels

of software developers. In the article at scala-lang.org, Martin Odersky defines the fol‐

lowing levels of computer programmers:

xvi | Preface

• Level A1: Beginning application programmer

• Level A2: Intermediate application programmer

• Level A3: Expert application programmer

• Level L1: Junior library designer

•

Level L2: Senior library designer

•

Level L3: Expert library designer

This book is primarily aimed at the application developers in the A1, A2, A3, and L1

categories. While helping those developers is my primary goal, I hope that L2 and L3

developers can also benefit from the many examples in this book—especially if they

have no prior experience with functional programming, or they want to quickly get up

to speed with Scala and its tools and libraries.

Contents of This Book

The first three chapters in this book cover some of the nuts and bolts of the Scala lan‐

guage.

Chapter 1, Strings, provides recipes for working with strings. Scala gets its basic String

functionality from Java, but with the power of implicit conversions, Scala adds new

functionality to strings through classes like StringLike and StringOps, which let Scala

treat a String as a sequence of Char. The last recipe in the chapter shows how to add

your own behavior to a String (or any other class) by creating an implicit conversion.

Chapter 2, Numbers, provides recipes for working with Scala’s numeric types. There are

no ++ and −− operators for working with numbers, and this chapter explains why, and

demonstrates the other methods you can use. It also shows how to handle large numbers,

currency, and how to compare floating-point numbers.

Chapter 3, Control Structures, demonstrates Scala’s built-in control structures, starting

with if/then statements and for loops, and then provides solutions for working with

for/yield loops (for comprehensions) and for expressions with embedded if statements

(guards). Because match expressions are so important to Scala, several recipes show

how to use them to solve a variety of problems.

The next five chapters continue to cover the Scala syntax, with an emphasis on organ‐

izing your projects with classes, methods, objects, traits, and packaging. Recipes on

classes, methods, objects, and traits place an emphasis on object-oriented programming

techniques.

Chapter 4, Classes and Properties, provides examples related to Scala classes and fields.

Because Scala constructors are very different than Java constructors, several recipes

show the ins and outs of writing both primary and auxiliary constructors. The chapter

Preface | xvii

also shows how to override the accessor and mutator methods that Scala automatically

generates for your val and var variables. Several recipes show what case classes are and

how to use them, and how to write equals methods.

Chapter 5, Methods, shows how to define methods to accept parameters, return values,

use parameter names when calling methods, set default values for method parameters,

create varargs fields, and write methods to support a fluent style of programming.

Chapter 6, Objects, covers “all things object.” Like Java, Scala uses the word object to

refer to an instance of a class, but Scala also has an object keyword. This chapter covers

topics like class casting, how to launch an application with an object, how to create the

equivalent of Java’s static members, and how to write a class with a companion object

so you can create new instances of a class without using the new keyword.

Chapter 7, Packaging and Imports, provides examples of Scala’s package and import

statements, which provide more capabilities than the same Java keywords. This includes

how to use the curly brace style for packaging, how to hide and rename members when

you import them, and more.

Chapter 8, Traits, provides examples of the Scala trait. It begins by showing how to use

a trait like a Java interface, and then gets into more advanced topics, such as how to use

traits as “mixins,” and limit which members a trait can be mixed into using a variety of

methods.

Although much of the book demonstrates functional programming (FP) techniques,

Chapter 9, Functional Programming, combines many FP recipes into one location. Sol‐

utions show how to define anonymous functions (function literals) and use them in a

variety of situations. Recipes demonstrate how to define a method that accepts a func‐

tion argument, how to return a function from a function, and how to use closures and

partially applied functions.

The Scala collections library is rich and deep, so Chapter 10, Collections, and Chapter 11,

List, Array, Map, Set (and More), provide more than 100 pages of collection-related

solutions.

Recipes in Chapter 10, Collections, help you choose collection classes for specific needs,

and then help you choose and use methods within a collection to solve specific problems,

such as transforming one collection into a new collection, filtering a collection, and

creating subgroups of a collection. More than 60 pages of recipes demonstrate solutions

for writing for loops, for/yield expressions, using methods like filter, foreach,

groupBy, map, and many more.

Chapter 11, List, Array, Map, Set (and More), continues where Chapter 10, Collections,

leaves off, providing solutions for those specific collection types, as well as recipes for

the Queue, Stack, and Range classes.

xviii | Preface

剩余721页未读，继续阅读

wujierd

粉丝: 1
资源: 22

Scala编程实例指南：英文高清版

Scala Cookbook epub

Scala Cookbook

Scala Cookbook 无水印pdf 0分

Scala编程实战：Scala Cookbook

Scala编程入门宝典：Scala Cookbook

Scala Cookbook 英文版增补精华

Scala Cookbook: 英文版JAVA函数式编程指南

2013年Alvin Alexander《Scala Cookbook》电子版详解

2013年Alvin Alexander《Scala Cookbook》文字版详解

Scala Cookbook (2.10版) - Alvin Alexander的经典教程

最新资源