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

需积分: 9 145 浏览量更新于2024-07-20 收藏 9.55MB PDF 举报

《Scala CookBook (2013.8)》是由Alvin Alexander编著的一本深入浅出的Scala编程指南。本书于2013年8月首次发行，享有Alvin Alexander的版权，并由O'Reilly Media出版，地址位于美国加利福尼亚州塞巴斯托波尔。该书适用于教育、商业或销售推广用途，同时在线版本也广泛提供，可以通过O'Reilly Safari Online平台获取。作为Scala编程领域的经典之作，本书以实用和详实的案例展示了Scala语言的强大功能和特性。作者Alvin Alexander以其丰富的经验和深入理解，将复杂的Scala概念通过易于理解的方式呈现给读者，适合从初学者到进阶开发者使用。书中涵盖了Scala的关键特性，如函数式编程、模式匹配、集合API、并发编程以及与Java的集成等，旨在帮助读者掌握如何在实际项目中高效利用Scala进行开发。本书由Courtney Nash担任编辑，Rachel Steely负责生产编辑，而Kim Cofer则负责校对工作。Linley Dolby负责了最后的校对确保准确无误。Indexer Ellen Troutman负责索引制作，保证内容查找的便捷性。封面设计由Karen Montgomery操刀，内部设计则由David Futato负责，插图由Rebecca Demarest绘制，共同打造了一本既美观又实用的技术书籍。《Scala CookBook》的第一版发布于2013年7月30日，如果读者想要获取更详细的错误修正信息，可以访问O'Reilly官网的发布详情页：http://oreilly.com/catalog/errata.csp?isbn=9781449339616。此外，本书还提到了几个重要的品牌标识，如Nutshell Handbook、Nutshell Handbook logo、O'Reilly logo以及特有的Scala CookBook中的长喙针鼹图像，这些都是O'Reilly Media公司的注册商标。《Scala CookBook (2013.8)》是一本权威且实用的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页未读，继续阅读

暉暉

粉丝: 11
资源: 29

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

在浏览器上运行 Scala Scala.js.zip

scala.xml.XML

import scala.collection中collection飘红

程序包scala.collection不存在

java.lang.ClassNotFoundException: scala.collection.Seq

scala 引用java list_如何在Java代码中使用scala.collection.immutable.List

Caused by: java.lang.ClassNotFoundException: scala.collection.mutable.ArraySeq$ofRef

如何解决scala.MatchError: WrappedArray(947,106, 812,366) (of class scala.collection.mutable.WrappedArray$ofRef)

import scala.util.control.Breaks._

最新资源