Scala学习笔记——入门

0.在 scala> 下运行Scala程序

首先cd到.scala文件所在的目录下

scalac这个scala文件，然后import package的名字.object的名字

然后就能使用 object的名字.def的名字来运行这个def

1.表达式

scala> 1 + 2
res0: Int = 3

2.变量定义,Scala中有两种变量,一种是var,一种val,val类似于Java里面的final变量,一旦初始化了,val就不能再次被赋值了

scala> var str = "Hello World"
str: String = Hello World
#lazy关键字修饰的变量，定义时不赋值，真正使用的时候才赋值
var str = "Hello World"

3.函数定义

object HelloWord {

def main(args: Array[String]) {
println("Hello Word")
println(max(1, 2))
println(args(0)+" "+args(1))
}

def max(x: Int, y: Int): Int = {
if (x > y)
x
else
y
}
}

输出

Hello Word
2
0 1

4.while循环和if判断

def printArg(args: Array[String]): Unit = {
var i = 0
while (i < args.length) {
println(args(i))
i += 1
}
}

5.foreach和for做枚举

def printArg1(args: Array[String]): Unit = {
//scala的foreach循环
args.foreach(arg => println(arg))
//foreach的简洁写法
args.foreach(println)
//args给arg传值
for(arg <- args)
println(arg)
}

6.类型参数化数组

def main(args: Array[String]) {
var big = new BigInteger("123")
val arr = new Array[String](3)
arr(0) = "1"
arr(1) = "2"
arr(2) = "3"
//或者
arr.update(0,"1")
arr.update(1,"2")
arr.update(2,"3")
for(i <- 0 to 2){
print (arr(i))
}
//最为简洁的创建和初始化数组的方法
var numArr = Array("1","2","3")

}

7.列表List

var list1 = List(1,2)
var list2 = List(3,4)
var list3 = list1:::list2
println (list3)
var list4 = 0::list3
println (list4)

输出

List(1, 2, 3, 4)
List(0, 1, 2, 3, 4)

一些方法

println (list4(2))
println (list4.count(s => s == 2))

输出

List(1, 2, 3, 4, 2)
2
2

8.元组Tuple

元组和列表都是不可变的，但是元组可以包含不同类型的元素

var pair = (123,"123")
println (pair._1)
println (pair._2)

输出

123
123

9.集合（set）和映射（map）

集合set和映射具有可变性和不可变性

var jetSet = Set("a","b")
jetSet += "c"　　　　　　//只有可变mutable集合有+=方法，如果是import scala.collection.immutable.Set，将会转换成mutable
println(jetSet.contains("c"))

输出

true

映射map

var map1 = Map[Int,String]()
map1 += (1 -> "1111")　　　//映射和集合也是一样的，映射也有可变和不可变之分
map1 += (2 -> "2222")
map1 += (3 -> "3333")
println (map1)

输出

Map(1 -> 1111, 2 -> 2222, 3 -> 3333)

直接定义映射

var map2 = Map(1 -> 1111, 2 -> 2222, 3 -> 3333)println (map2)

10函数式编程

从

while (i < args.length) {
println(args(i))
i += 1
}

到

for(arg <- args)
println(arg)

的过程就是函数式编程

11.从文件里读取文本行

if(args.length > 0){
for(line <- Source.fromFile(args(0)).getLines){
println(line.length+" "+line)
}
}

//行数数字的长度
def widthOfLength(s: String) = s.length.toString.length

def readFile(args: Array[String]): Unit = {
if (args.length > 0) {
var lines = Source.fromFile(args(0)).getLines.toList
//有空格
var maxWidth = 0
for (line <- lines) {
maxWidth = maxWidth.max(widthOfLength(line))
}
for (line <- lines) {
var numSpace = maxWidth - widthOfLength(line)
var padding = " " * numSpace
println(padding + line.length + " | " + line)
}
//无空格
//      for(line <- Source.fromFile(args(0)).getLines){
//        println(line.length+" "+line)
//      }
}
}

12.类和对象

　　1.Scala中不用加上分号,但是如果一行中有多个语句的话,分号是必须的

　　2.Scala比Java更为面向对象的特点之一是Scala不能定义静态变量,而是代之以定义单例对象(singleton object),所要做的就是用object关键字取代class关键字.

　　　　当单例对象Object和某个类共享同一个名称的时候,它就被称为是这个类的伴生对象.类和它的伴生对象可以互相访问气私有对象.

object ChecksumAccumulator {
private var cache = Map[String, Int]()

def main(args: Array[String]) {
System.out.println(calculate("abc"))
System.out.println(calculate("a"))
System.out.println(cache)
}

def calculate(s: String): Int = {
if (cache.contains(s))
cache(s)
else {
val acc = new ChecksumAccumulator
for (c <- s)
acc.add(c.toByte)
val cs = acc.checkSum()
cache += (s -> cs)  //把map赋值给cache
cs
}
}

}

class ChecksumAccumulator {
private var sum = 0

def add(b: Byte): Unit = sum += b //不超过-128-127

def checkSum(): Int = ~(sum & 0xFF) + 1
}

　　3.除了使用main方法来定义程序的入口之外，Scala还提供了特质scala.Application，可以减少一些输入工作。

import ChecksumAccumulator.calculate

object FallWinterSpringSummer extends Application{
for (season <- List("fall","winter","spring","winter")){
println(season+": "+calculate(season))
}
}

13.基本类型



在Scala中 == 是比较内容，而在Java中是比较引用，这是Scala和Java中不同的地方

运算符优先级



14.字面量

14.1——[b]整数字面量[/b]

类型Int，Long，Short和Byte的整数字面量有3种格式：10进制，16进制（以0x或者0X开头），8进制（以0开头）

如果整数字面量是以L或者l结尾的话，就是Long类型

如果Int类型的字面量被赋值给Short或者Byte类型的变量，字面量就会被当成是被赋值的类型，以便让字面量值处于有效范围内

14.2——浮点[b]字面量[/b]

浮点数字面量是由十进制数字、可选的小数点、可选的E或者e及指数部分组成的。

14.3——[b]字符字面量[/b]

字符字面量可以是在单引号之间的任何Unicode字符，如

val a = 'A'
val a = '\101'
val a = '\u0041'
val B\u0041\u0044 = 1

14.4——[b]字符串字面量[/b]

[b]

[/b]

14.5——符号[b]字面量[/b]

符号字面量被写成‘<标识符>，这里的<标识符>可以是任何字母或者数字的标识符。这种字面量被映射成预定义类scala.Symbol的实例，可以使用在更新数据库记录的方法中

def updateRecordByName(r:Symbol,value:Any): Unit ={

}

updateRecordByName('a,"a")

如果同一个符号字面量出现两次，那么两个字面量指向的是同一个Symbol对象

15.操作符和方法，Scala的数学运算，关系和逻辑操作，位操作符，和Java的差不多


Scala的操作符+支持重载，比如1+1L的结果就是Long型的

16.对象相等性

如果想要比较一下两个对象是否相等，可以使用==，==操作符对所有的对象都起作用，而不仅仅是基本类型

17.富包装器