Scala 学习笔记

最新推荐文章于 2025-08-14 18:26:42 发布

转载最新推荐文章于 2025-08-14 18:26:42 发布 · 128 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：https://my.oschina.net/xiejunbo/blog/495734

文章标签：

#scala #java #python

2019独角兽企业重金招聘Python工程师标准>>>

一、Scala简介

Scala(Scalable Language)是一门多范式编程语言。

发布于2004年6月。

2009年4月，Twitter宣布把大部分后端程序从Ruby迁移到Scala.

Scala特性：面向对象特征，函数式编程，静态类型，扩展性，并发性（Scala使用了Actor作为其并发模型）。

Scala Web框架:Lift框架，Play框架。

二、Scala安装及环境配置

Scala可运行在windows,linux,unix,mac os等系统上。

Scala是基于JAVA的，大量使用了java类库和变量，必须使用JDK>1.5以上版本。

安装Scala时需添加bin路径到环境变量。

三、Scala基础语法

Scala与java的最大区别是：Scala语句末尾的分号;是可选的。

可以认为Scala程序是对象的集合，可以通过调用彼此的方法来实现消息传递。

(对象，类，方法，字段)

第一个Scala程序

交互式编程：（交互式编程不需要脚本文件，可通过以下命令调用）

$ scala
Welcome to Scala version 2.11.7 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_31).
Type in expressions to have them evaluated.
Type :help for more information.

scala> 1 + 1
res0: Int = 2

scala> println("Hello World!")
Hello World!

scala>

脚本形式：（可以通过创建Helloworld.scala文件来执行代码）

object HelloWorld{

    /*
     * 第一个scala程序
     */
    def main(args:Array[String]){
        println("Hello world");
    }
}

用scalac 命令编译：

$ scalac HelloWorld.scala
$ ls
HelloWorld$.class HelloWorld.scala
HelloWorld.class

编译后可用以下命令执行：

$ scala HelloWorld
Hello, World!

基本语法：

区分大小写：大小写敏感

类名：所有类名的第一个字母要大写，多个单词构成一个类名时，每个单词首字母大写

方法名称：所有方法名称的首字母小写，多个单词构成一个方法名时，每个单词首字母大写

程序文件名：程序文件名要与对象名称完全匹配

标识符：Scala可用两种形式的标识符：字符数字和符号

Scala命名规则采用java类似的camel命名规则

Scala关键字：

abstract,def,false,forSome,lazy,object,protected,this,true,while,-,<-,#,case,do,final,if,match,override,return,throw,type,with,:,<:,@,catch,else,finally,implicit,new,package,sealed,trait,val,yield,=,<%.

Scala注释：跟JAVA注释一样

换行符：Scala是面向行的语言，语句可以用分号;结束或换行符。

Scala包：

定义包：有两种方式
第一种类JAVA,

package com.xiejunbo
class HelloWorld

第二种类C#

package com.xiejunbo {
    class HelloWorld
}

第二种可以在一个文件中定义多个包。

引用：使用import关键字引用包，import语句可以出现在任何地方，而不是只能在文件顶部。import的效果从开始延伸到语句块的结束。

import java.awt.Color  // 引入Color
 
import java.awt._  // 引入包内所有成员
 
def handler(evt: event.ActionEvent) { // java.awt.event.ActionEvent
  ...  // 因为引入了java.awt，所以可以省去前面的部分
}

如果想引入包中的几个成员，可用selector:

import java.awt.{Color,Font}
//重命名成员
import java.util.{HashMap => JavaHashMap}
//隐藏成员
import java.util.{HashMap => _, _}//引入了util包的所有成员，但HashMap被隐藏了

四、Scala数据类型

Scala与JAVA有着相同的数据类型,下面为Scala支持的数据类型：

Byte,Short, Int,Long,Float,Double,Char,String,Boolean,Unit,Null,Nothing,Any,AnyRef.

整型字面量：整型字面量用于 Int 类型，如果表示 Long，可以在数字后面添加 L 或者小写 l 作为后缀。

浮点型字面量：浮点数后面有f或者F后缀时，表示这是一个Float类型，否则就是一个Double类型的。

布尔类型字面量：true/false

符号字面量：符号字面量被写成： '<标识符> ，这里 <标识符> 可以是任何字母或数字的标识（注意：不能以数字开头）。这种字面量被映射成预定义类scala.Symbol的实例

字符字面量：在scala中字符类型表示为半角单引号(')中的字符

字符串字面量：字符串表示方法是在双引号中(") 包含一系列字符

多行字符串的表示方法：多行字符串用三个双引号来表示分隔符，格式为："""..."""

例如:

val test = """ xiejunbo
xiejunbo1
xiejunbo2
xiejunbo3"""

Null值：空值是scala.Null类型。Scala.Null和scala.Nothing是用统一的方式处理Scala面向对象类型系统的某些"边界情况"的特殊类型。

Scala转义字符：

\b 退格

\t 水平制表

\n 换行

\f 换页

\r 回车

\“ 代表一个双引号字符

\' 代表一个单引号字符

\\ 代表一个反斜杠

例：

object Test{
    def main(args:Array[String]){
        println("Hello\tWorld\n\n);
    }
}

五、Scala变量

在Scala中,使用var声明变量，val声明常量。

//声明了变量myVar,可修改
var myVar : String = "test";
var myVar : String = "test2";

//声明常量myVal，不能修改
var myVal : String = "test3";

变量类型声明：

//变量的类型在变量名之后等号之前声明。语法如下
var VariableName : DataType [= Initial Value]
或
val VariableName : DataType [= Initial Value]

//变量声明不一定要初始化
var myVar : Int;
var myVal : String;

变量类型引用：

//在Scala中声明变量和常量不一定要指明数据类型，在没有指明数据类型的情况下，
//其数据类型是根据变量或常量的初始值推断出来的。
//所以如果在没有指明数据类型下声明变量或常量必须要给出其初始值，否则报错
var myVar = 10;
var myVal = "xiejunbo";

Scala多个变量声明：

//支持多个变量的声明
var xmax,ymax = 100;//xmax,ymax都声明为100
//如果返回值是元组，可用val来声明一个元组
val (myVar1 :Int, myVar2:String) = Pair(1,"xiejunbo");
//也可不指定数据类型
val (myVar1,myVar2) = Pair(1, "xiejunbo");

六、Scala访问修饰符

Scala访问修饰符基本和JAVA一样，分别有private, protected, public.

没有指定访问修饰符时默认public.

Scala中的private比JAVA更严格，在嵌套类情况下，外层类甚至不能访问被嵌套类的私有成员。

私有成员Private：

Class Outer{
    class Inner {
        private def f(){println("xiejunbo");}
        class InnerMost{
        f();//正确
        }
    }
    (new Inner).f();//错误
}

保护成员Protected:

package p{
class Super{
    protected def f() {println("f")}
    }
	class Sub extends Super{
	    f()
	}
	class Other{
		(new Super).f() //错误
	}
}

公共成员Public:

Scala中，如果没有指定任何的修饰符，则默认为 public。这样的成员在任何地方都可以被访问。

作用域保护：

//Scala中，访问修饰符可以通过使用限定词强调，格式为：
private[X] 
或
protected[X]
//这里的x指代某个所属的包、类或单例对象。如果写成private[x],读作"这个成员除了对[…]中的类或[…]中的包
中的类及它们的伴生对像可见外，对其它所有类都是private。

package bobsrocckets{
    package navigation{
        private[bobsrockets] class Navigator{
         protected[navigation] def useStarChart(){}
         class LegOfJourney{
             private[Navigator] val distance = 100
             }
            private[this] var speed = 200
            }
        }
        package launch{
        import navigation._
        object Vehicle{
        private[launch] val guide = new Navigator
        }
    }
}

上述例子中，类Navigator被标记为private[bobsrockets]就是说这个类对包含在bobsrockets包里的所有的类和对象可见。

比如说，从Vehicle对象里对Navigator的访问是被允许的，因为对象Vehicle包含在包launch中，而launch包在bobsrockets中，相反，所有在包bobsrockets之外的代码都不能访问类Navigator。

七、Scala运算符

算术运算符：+, -, *, /, %

关系运算符：==, !=, >, <, >=, <=

逻辑运算符：&& , || , !

位运算符：~取反，&按位与与，|按位与或，^按位与异或，<<左移动，>>右移动， >>>无符号右移

赋值运算符：=, +=, -=, *=, /=, %=, <<=, >>=, &=, ^=, |=

运算符优先级：

指针最优，单目运算优于双目运算，如正负号。

先乘除模，后加减。

先算术运算，后移位运算，最后位运算。

逻辑运算最后计算。

八、Scala IF.ELSE语句

object Test{
    def main(args:Array[String]){
        var x = 10;
        if (x < 20){
            println("x < 20");
        }
    }
}

九、Scala循环

//导入以下包
import scala.util.control._

//创建Break对象
val loop = new Breaks;

//在breakable中循环
loop.breakable{
    //循环
    for (...){
        ...
       //循环中断
       loop.break;
    }
}

十、Scala函数

def functionName ([参数列表]) : [return type] = {
   function body
   return [expr]
}

例：

object add{
   def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b

      return sum
   }
}

函数调用：

object Test{
    def main(args:Array[String]){
        println("Returned Value:" +  addInt(5,7));
    }
    def addInt(a:Int, b:Int):Int = {
        var sum:Int = 0;
        sum = a + b;
        return sum;
    }


}

十一、Scala闭包

闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。

十二、Scala字符串

创建字符串：

var greeting = "Hello World!";

或

var greeting:String = "Hello World!";

可以在Scala中使用java.lang.String中常用的方法：

序号	方法及描述
1	char charAt(int index) 返回指定位置的字符
2	int compareTo(Object o) 比较字符串与对象
3	int compareTo(String anotherString) 按字典顺序比较两个字符串
4	int compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写
5	String concat(String str) 将指定字符串连接到此字符串的结尾
6	boolean contentEquals(StringBuffer sb) 将此字符串与指定的 StringBuffer 比较。
7	static String copyValueOf(char[] data) 返回指定数组中表示该字符序列的 String
8	static String copyValueOf(char[] data, int offset, int count) 返回指定数组中表示该字符序列的 String
9	boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束
10	boolean equals(Object anObject) 将此字符串与指定的对象比较
11	boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写
12	byte getBytes() 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中
13	byte[] getBytes(String charsetName 使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中
14	void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此字符串复制到目标字符数组
15	int hashCode() 返回此字符串的哈希码
16	int indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引
17	int indexOf(int ch, int fromIndex) 返返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索
18	int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引
19	int indexOf(String str, int fromIndex) 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
20	String intern() 返回字符串对象的规范化表示形式
21	int lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引
22	int lastIndexOf(int ch, int fromIndex) 返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索
23	int lastIndexOf(String str) 返回指定子字符串在此字符串中最右边出现处的索引
24	int lastIndexOf(String str, int fromIndex) 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索
25	int length() 返回此字符串的长度
26	boolean matches(String regex) 告知此字符串是否匹配给定的正则表达式
27	boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) 测试两个字符串区域是否相等
28	boolean regionMatches(int toffset, String other, int ooffset, int len) 测试两个字符串区域是否相等
29	String replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的
30	String replaceAll(String regex, String replacement 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串
31	String replaceFirst(String regex, String replacement) 使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串
32	String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串
33	String[] split(String regex, int limit) 根据匹配给定的正则表达式来拆分此字符串
34	boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始
35	boolean startsWith(String prefix, int toffset) 测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
36	CharSequence subSequence(int beginIndex, int endIndex) 返回一个新的字符序列，它是此序列的一个子序列
37	String substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串
38	String substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串
39	char[] toCharArray() 将此字符串转换为一个新的字符数组
40	String toLowerCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为小写
41	String toLowerCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为小写
42	String toString() 返回此对象本身（它已经是一个字符串！）
43	String toUpperCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为大写
44	String toUpperCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为大写
45	String trim() 删除指定字符串的首尾空白符
46	static String valueOf(primitive data type x) 返回指定类型参数的字符串表示形式

十三、Scala数组
十四、Scala Collection
十五、Scala Iterator(迭代器)
十六、Scala类和对象
十七、Scala Trait(特征)
十八、Scala模式匹配
十九、Scala正则表达式
二十、Scala异常处理

Scala抛出异常方法和JAVA一样。

import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException

object Test {
   def main(args: Array[String]) {
      try {
         val f = new FileReader("input.txt")
      } catch {
         case ex: FileNotFoundException =>{
            println("Missing file exception")
         }
         case ex: IOException => {
            println("IO Exception")
         }
      }
   }
}

二十一、Scala提取器Extrator

二十二、Scala文件IO

转载于:https://my.oschina.net/xiejunbo/blog/495734