scala（13）
为什么要学习scala?在学习任何一门语言的时候，我们都会问自己这样的问题，我为什么要学它，因为每学习一门语言我们都要花费大量时间和精力，学一门语言就像是和一个女生谈一场恋爱，从写“HelloWorld”开始，到后面的变量、数组、循环、面向对象（过程）、异常处理、文件操作ooooo我们渐渐了解，渐渐熟悉，从相知到相恋，相恋到相守oooooo
每一门语言都有它的优缺点和适用的地方，就像每一个女生都有她独特的性格，那么scala这个女生到底有哪些吸引我们的地方呢？我在知乎上看到有人总结了一些，包括快速实验、类型安全、面向对象、函数式编程、基于JVMoooooo，哈哈，初学者们一定不了解这一大堆词到底说的是什么吧，我们现在不管，反正记住，scala有很多个好处就是了，日后我们再逐个讨论。
感觉说了很多废话了，那么下面就正式开始scala学习之旅吧。
首先说一下怎样去写scala代码，学习scala最简单的是用scala解释器，这是一种编写交互式的”shell”,在解释器中输入表达式立马就能打印出结果值（前提是你先安装好jdk和scala）。 第二种写scala的地方是可以在sublime里边写，做一下简单的配置就可以了，我用的是sublime2,也很方便。 如果要做项目开发，我建议用IDEA(IntelliJ IDEA)，里面可以安装各种插件，程序员想要的都有，平时项目开发中我一般都用这个。
知道在哪里些代码，就可以动手去实践了，是不是太快了？哈哈，实践才能出真知嘛！学语言我建议通过实践来学，也就是在代码中去学，不要光那这书一天到晚的看。说一个有趣的事情，有一次我一个同事学Java,于是抱着一本《Java编程思想》看了好几天，准备写程序的时候，却连个“Helloword”都调了半天才出来，于是开玩笑到，思想已经跑的太远，忘记了当初为什么出发oooooo
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：11087次
排名：千里之外
原创：26篇
转载：17篇
(6)(4)(8)(3)(22)后使用快捷导航没有帐号？
查看: 1816|回复: 19
scala 和ruby 和 python 学哪个好（求助）
中级会员, 积分 312, 距离下一级还需 188 积分
论坛徽章:16
和ruby 和 python 学哪个好？
中级会员, 积分 312, 距离下一级还需 188 积分
论坛徽章:16
请大牛指点
中级会员, 积分 317, 距离下一级还需 183 积分
论坛徽章:6
中级会员, 积分 489, 距离下一级还需 11 积分
论坛徽章:0
基于spark的开发用scala，基本的数据分析用python
论坛徽章:42
都学，这个要不少时间吧。
中级会员, 积分 317, 距离下一级还需 183 积分
论坛徽章:6
都学，这个要不少时间吧。
楼主都那么多徽章了，不是小case吗
论坛徽章:42
楼主都那么多徽章了，不是小case吗
本人其实很水的，也只能灌灌水吧。
注册会员, 积分 192, 距离下一级还需 8 积分
论坛徽章:20
哇，这么多徽章啊，帖子都上万了
金牌会员, 积分 1246, 距离下一级还需 1754 积分
论坛徽章:17
为 Spark 学 Scala，Python 比较简便，Java 必备。
新手上路, 积分 18, 距离下一级还需 32 积分
论坛徽章:1
我学SCALA主要是为了SPARK开发，在TIOBE排名中还是PYTHON比较靠前一点Scala开发参照清单
这里列出在开发一个Scala工程中需要参照的资料。
Cheatsheet
Language Specification
Scala wiki
Scala Tools and Libraries
Scala的初次约
Scala是由Martin Odersky设计的一种结合了函数式编程（不仅仅有这个）的强类型语言。
Scala的代码会被编译成Java bytecode，并在JVM上运行的。
可以认为Scala是Java的扩充，一个Java语言的超集。
Scala的设计思想之一，来自于对Java语言的一些缺点的批评。
个人也觉得Java语言发展的太慢，尤其是和C#、.NET相比。
Scala的横空出世，提供了一个积极性的灵感，解决了Java语言的发展问题，给Java社区带来强大的活力。
Scala的优势
Java有的优势，Scala都有
Scala的编程风格更简洁
Scala的简洁风格，也很可能降低可读性。所以在团队开发中，还是需要一个良好的代码规范来约束。
和Java的性能一样，比Python快的太多了。
可以直接使用Java类库。
Java也可以使用Scala的类库。
个别情况下，需要在Scala里做特殊的支持。
Scala的用途
结合Spark，处理大数据。
这是，目前，Scala的一个主要应用。Spark也是那Scala写的。
Java的脚本语言版
可以直接写Scala的脚本，也可以在.sh直接使用Scala。
代替Java。
scala希望提供一种简洁的语言。不过作为初学者的我，scala极其容易导致代码的可读性比较差。
Java语言还是有其优势。
Scala的代码风格
由于Scala结合了函数式编程和面向对象语言特征，从这个方面看，有两种编程风格可以选用。
支持函数式编程的面向对象编程风格
函数式编程风格
如果你开发的项目主要用于处理数据，函数式编程风格更适用。
本文也主要针对函数式编程风格。
可以从scala的上下载。
许多人会选择Intellij IDEA或者Eclipse作为scala的编辑器。
这里有个使用Visual Studio Code作为编辑器的介绍：
函数式编程到底意味着什么
Scala的再认识
trait， class，object
开始学习Scala会看到trait这个奇怪的词，而且可以def object。这里解释一下：
trait： 类似于Interface，不过可以实现声明的方法。
class: 就是class.
object: 就是Module，一个静态类。
Scala的语言特征
除了Java的语言特征外，Scala还提供了一下主要特征。
（这个章节比较深奥，可能不足，需要慢慢地更新）
函数式编程(functional programming)
上面已经说过了。
类型推测（typing inference）
这个特征C#也有。建议大家尽量使用这个特点。也就是说
避免定义变量的数据类型
一个好处是类型发生变化的时候，改动的代码会相对较少。
对于函数，要定义输入和输出的数据类型。
implicit特性
我把对implicit的认识分为这几个Levels。
Level 0: 完全忽略implicit的存在
如果，你在你的项目里发现有人使用implicit，可以理直气壮地批评，这是降低可读性的杰作。
implicit特性应该避免被使用。implicit很可能给读代码的人带来困惑，属于反直觉的代码。
Level 1：简单的认识implicit conversions
比如：一个函数的参数的Long型，调用时输入一个Int型的数据，也不会出错，
其后面就是implicit conversions功劳。
implicit conversions逻辑发现类型Int/Long不匹配，
然后在一个implicit view（可以看成一个函数pool，包含了所有的implicit functions）中找一个输入为Int，输出为Long的函数，
最后通过这个函数完成类型的转换。
Scala自身提供了一些必要的implcite conversion functions.
Level 2: 对implicit的有个基本理解
implicit的使用
使用起来很简单，直接把implicit关键字，加到trait/class/object/def/val之前就可以。
在Scala 2.10版后, implicit可以用在三个地方:
implicit functions vs implicit conversions
implicit def int2ordered(x: Int): Ordered[Int] =
new Ordered[Int] { /* .. */ }
implicit classes
implicit classes是针对Pimp-my-library pattern，在Scala语法上的实现。
这个和C#的extesion methods的用意是一样的。
比如，你想在Scala的List类上，增加一个函数，而不用去修改Scala的发布包，
在Scala 2.10版以后，就可以通过implicit classes实现，
之前的版本，可以通过Pimp-my-library pattern实现。
在下面这个例子中，如果import Helpers._，类IntWithTimes的所有方法都会作用于Int上。
object Helpers {
implicit class IntWithTimes(x: Int) {
def times[A](f: =& A): Unit = {
def loop(current: Int): Unit =
if(current & 0) {
loop(current - 1)
implicit values vs implicit parameters
来自官方的一个例子：
object ImplicitTest extends App {
To show how implicit parameters work,
we first define monoids for strings and integers.
The implicit keyword indicates that the corresponding object can be used
implicitly, within this scope, as a parameter of a function marked implicit.
implicit object StringMonoid extends Monoid[String] {
def add(x: String, y: String): String = x concat y
def unit: String = &&
implicit object IntMonoid extends Monoid[Int] {
def add(x: Int, y: Int): Int = x + y
def unit: Int = 0
This method takes a List[A] returns an A which represent the combined
value of applying the monoid operation successively across the whole list.
Making the parameter m implicit here means we only have to provide
the xs parameter at the call site, since if we have a List[A]
we know what type A actually is and therefore what type Monoid[A] is needed.
We can then implicitly find whichever val or object in the current scope
also has that type and use that without needing to specify it explicitly.
def sum[A](xs: List[A])(implicit m: Monoid[A]): A =
if (xs.isEmpty) m.unit
else m.add(xs.head, sum(xs.tail))
Here we call sum twice, with only one parameter each time.
Since the second parameter of sum, m, is implicit its value is looked up
in the current scope, based on the type of monoid required in each case,
meaning both expressions can be fully evaluated.
println(sum(List(1, 2, 3)))
// uses IntMonoid implicitly
println(sum(List(&a&, &b&, &c&)))
// uses StringMonoid implicitly
implicit的功能可以分为两类：
implicit conversions (from implicit functions and implicit classes)
当Scala发现类型不匹配，或者正在调用一个对象不存在的函数时，
Scala compiler就会去implicit function list中找一个匹配的函数。
implicit arguments (from implicit values and implicit objects)
在函数上可以定义一个implcit参数，编译器会在implicit的对象列表中，
找到一个类型匹配的对象，并传入。
可以想到，implicit有个作用域。这个作用域，和当前的package，以及import的类，
还有Scala的默认有关。
Level 3: 重申：避免使用implicit
Level 4: 如果要使用implicit
好好阅读关于implicit作用域，编译器的查找complicit对象的顺序等知识。
定义implicit的开发规范
写好文档帮助开发人员和用户理解。
限制其使用的场景
你要实现一个类似于虚数这样的新数据类型。
Collection
Mutability vs Immutability
可变的变量(Mutable variables)（主要是可变的对象）会引起一些潜在的问题：
变化后，可能在map中找不到了
性能损失（在多线程下，读写需要加锁）
编程方面的建议是：
如果可能，使用和开发 immutable 类。
Null, null, Nil, Nothing, None, and Unit
Null是Scala中的一个Trait.
null是一个Null的实例，相当于Java中的null。在面向函数编程中，不要使用，用None代替。
None是一个None.type的实例，代替null。
在一个函数中，用于表达这个函数返回了没有值。可以避免 null pointer exception。
Unit是Scala中的一个类型，用于表示一个函数没有返回值。
有点像Java中的void，不过其实返回了'()'。
// There is no '=' before '{', so the function return Unit.
def funUnit(x: Int) {
// There is a '=' before '{',
// so the function returns the value of the last expression.
def funReturnLastStatement(x: Int) = {
// Recommend to use explicit return type, and = forever.
def funReturnLastStatementGood(x: Int) : Int = {
Nil 是一个空的List实例.
Nothing是Scala中的一个Trait。基本上没有用。（我猜的）
## 和 == 对 equals 和 hashCode
在Scala中, ##方法相当于Java中的hashCode方法。
==方法相当于Java中的equals方法。
建议使用##和==，因为Scala针对value类型实现额外的功能。
Generic classes/functions: +T, -T， &:, &:, &&
+T: 作用于class, 用于协变(covariant)
-T：作用于class, 用于逆变(contravariant)
+T, -T 作用于泛型对象之间赋值。
T &: A: 作用于 function, 约束：T是A的子类，也称作upper type bound，这是一个协变。
一般会和-T合用。
T &: A: 作用于 function, 约束：T是A的超类，也称作lower type bound，这是一个逆变。
一般会和+T合用。
T && A: 作用于 function, 约束：存在一个T =& A的implicit conversion，也称作view bound.
&:, &:, && 作用于泛型函数之间赋值。
编译.scala文件到jar文件
scalac -d test.jar D:\project\*
Scala in Depth by ScalaJoshua D. Suereth
阅读(...) 评论()}