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——整数字面量
类型Int，Long，Short和Byte的整数字面量有3种格式：10进制，16进制（以0x或者0X开头），8进制（以0开头）
如果整数字面量是以L或者l结尾的话，就是Long类型
如果Int类型的字面量被赋值给Short或者Byte类型的变量，字面量就会被当成是被赋值的类型，以便让字面量值处于有效范围内
14.2——浮点字面量
浮点数字面量是由十进制数字、可选的小数点、可选的E或者e及指数部分组成的。
14.3——字符字面量
字符字面量可以是在单引号之间的任何Unicode字符，如
val a = 'A' val a = '101' val a = 'u0041' val Bu0041u0044 = 1
14.4——字符串字面量
14.5——符号字面量
符号字面量被写成‘<标识符>，这里的<标识符>可以是任何字母或者数字的标识符。这种字面量被映射成预定义类scala.Symbol的实例，可以使用在更新数据库记录的方法中
def updateRecordByName(r:Symbol,value:Any): Unit ={
}
updateRecordByName('a,"a")
如果同一个符号字面量出现两次，那么两个字面量指向的是同一个Symbol对象
15.操作符和方法，Scala的数学运算，关系和逻辑操作，位操作符，和Java的差不多
Scala的操作符+支持重载，比如1+1L的结果就是Long型的
16.对象相等性
如果想要比较一下两个对象是否相等，可以使用==，==操作符对所有的对象都起作用，而不仅仅是基本类型
17.富包装器
