Key points of this chapter:
• Use an Array if the length is fixed, and an ArrayBuffer if the length can vary.
• Don’t use new when supplying initial values.
• Use () to access elements.
• Use for (elem <- arr) to traverse the elements.
• Use for (elem <- arr if . . . ) . . . yield . . . to transform into a new array.
• Scala and Java arrays are interoperable; with ArrayBuffer, use scala.collection.
JavaConversions. (查看原文)
A tuple value is formed by enclosing individual values in parentheses. For
example,
(1, 3.14, "Fred")
is a tuple of type
Tuple3[Int, Double, java.lang.String]
which is also written as
(Int, Double, java.lang.String) (查看原文)
The traditional approach, in which concurrent tasks have side effects that mutate shared data, is tedious and error-prone. Scala encourages you to think of a computation in a functional way. A computation yields a value, sometime in the future. As long as the computations don’t have side effects, you can let them run concurrently and combine the results when they become available. (查看原文)
A data structure that assigns tasks to threads is usually called a thread pool. In Java, the Executor interface describes such a data structure. Scala uses the ExecutionContext trait instead. (查看原文)
The java.util.concurrent package has a Future interface that is much more limited than the Scala Future trait. A Scala future is equivalent to the CompletionStage interface in Java 8. (查看原文)
A Future object is read-only. The value of the future is set implicitly when the task has finished or failed. A Promise is similar, but the value can be set explicitly.
The producer, however, has more flexibility when using a Promise. (查看原文)
By default, Scala futures are executed on the global fork-join pool. That works well for computationally intensive tasks.
The Executors class from the Java concurrency library gives you several choices. A cached thread pool works well for I/O intensive workloads. (查看原文)
