Scala 运行在Java虚拟机上,并兼容现有的Java程序。
Scala 源代码被编译成Java字节码,所以它可以运行于JVM之上,并可以调用现有的Java类库。
1.object HelloWorld {
/* 这是我的第一个 Scala 程序
* 以下程序将输出'Hello World!'
*/
def main(args: Array[String]) {
println("Hello, world!") // 输出 Hello World
}
}
2.for循环
var s = “abcde”
for(i <- s) println(i)
//定义数组
var arr = Array(1,2,3,4,5)
for(i <- arr) println(i)
//泛型
var arr = Array[Strinig](“a”,”b”,”c”)
//将一个int数组中的每个值 +1 后再生成一个数组
var arr = Array(1,2,3,4,5,6,7,8,9)
arr.map(_ + 1) //原数组不动,生成新的数组
//将偶数查出,再乘以10
arr.filter(_ % 2 == 0) 或 arr.filter(i => i % 2 == 0).map(_ * 10)
3.定义方法
def main() { println(“123”)}
// 关键字,方法名,参数,返回类型,返回结果
def m1(a: Int, b: Int) : Int = a + b
def m2(a: Int, b: Int) = {
a + b
“abc”
}
不定义返回类型会自动推断,最后一行等于返回值
Unit == void
递归方法必须有返回值类型
4.定义函数
必须有一个对象引用
val f1 = (a: Int, b: Int) => a + b
//与方法的区别,函数可以当作参数传入方法中
arr.map(_ * 100) //括号中是匿名函数
arr.map( (a: Int) => a *100 ) //与上边等价
arr.map( (a) => a *100 ) //不写类型,可自动推断
arr.map( a => a *100 ) //只有一个参数,可省略括号
优点:可以将业务逻辑封装成函数后当作参数传递,数据源不变,而不用事先写好方法(不灵活)
val f2:(Int, Double) => (Double, Int) = {(a, b) => (b, a * 10)}
val 函数名:参数 => 返回类型(多个用括号) = {(参数1, 参数2) => (返回值1, 返回值2)}
5.定义方法参数为函数
参考 def m2(a: Int) { println( a ) }
def m2(a: (Int, Int) => Int) {
val x = 4;
val y = 5;
println( a(x, y) )
}
val f2 = (i: Int, j: Int) => i * j //定义函数
m2(f2) //传参
6.var a = 0;
for( a <- 1 to 10){
println( "Value of a: " + a );
}
for( a <- 1.to(10)){
println( "Value of a: " + a );
}
to 换成 until
for( a <- 1 to 3; b <- 1 to 3){
println( "Value of a: " + a );
println( "Value of b: " + b );
} //双层 for 循环
Value of a: 1
Value of b: 1
Value of a: 1
Value of b: 2
Value of a: 1
Value of b: 3
Value of a: 2
Value of b: 1
Value of a: 2
Value of b: 2
Value of a: 2
Value of b: 3
Value of a: 3
Value of b: 1
Value of a: 3
Value of b: 2
Value of a: 3
Value of b: 3
7.数组
val arr = Array(“a”,”b”)
arr(0) //获取值
arr(0) = “aa” //?能否改变
val arr = new Array[Int](5) //定长数组
import scala.collection.mutable.ArrayBuffer //变长数组需要导入包
val arr = new ArrayBuffer[Int]
arr.append(1) 或 arr += 1 //增加值
arr ++= Array(3,4,5) //追加另一个集合
arr.sum、arr.max、arr.min、arr.length
8.集合
val list: List[String] = List("Runoob", "Google", "Baidu")
list.apply(2)
默认情况下,Scala 使用的是不可变集合,如果你想使用可变集合,需要引用 scala.collection.mutable._ 包
import scala.collection.mutable._ //引入所有,不是*
val list: ListBuffer[String] = ListBuffer("Runoob", "Google", "Baidu")
val set = Set(1,2,3,4,5)
set += 6 //如果是不可变set会报错
同上需要引入mutable.Map
val map = Map[String, Int]()
map += (“a” -> 12)
9.元组
val t = (1, 3.14, "hello")
t._1 //结果是 1
t._2 //结果是 3.14
t._3 //结果是 Fred
val t = new Tuple3(1, 3.14, "hello")
10.wordcount——统计数字出现次数,排序
val line = "hello world da jia hao hello all hello kitty"
line.split(" ") == 一个数组,
//如果是一个多行数组
val arr = Array("hello world", "da jia hao", "hello all hello kitty")
arr.map(l => l.split(" "))
arr.map(l => l.split(" ")).flatten 等价于 arr.flatMap(l => l.split(" "))
最终简写:arr.flatMap(_.split(" "))
将单词转成元组:arr.flatMap(_.split(" ")).map((_, 1))
arr.flatMap(_.split(" ")).map((_, 1)).groupBy(_._1) //按元组1分组
……上略:.map(t => (t._1, t._2.length)) //元组2的个数
排序:.toList.sortBy(_._2).reverse //map无法排序转list,按Tuple2
11.对象,类
一个Scala源文件中可以有多个类,类名和文件名不必一致
import java.io._
class Point(xc: Int, yc: Int) {
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
println ("x 的坐标点: " + x);
println ("y 的坐标点: " + y);
}
}
object Test { //静态类,不可以有参数
def main(args: Array[String]) {
val pt = new Point(10, 20);
// 移到一个新的位置
pt.move(10, 10);
}
}
12.伴生对象
伴生对象:与类共享名字,可以访问类的私有属性和方法(同文件中)
private[this] //彻底私有,伴生对象也不可访问
object 类名 //静态,可直接访问其属性,没有构造器
class 类名 //需要new,才可访问其属性
主构造器的参数可当作类属性
class Test(var a: Int) { }
val t = new Test(100);println(t.a) //没错
辅助构造器:def this(a: Int, b: Int){ this(a) } //第一行必须调一下主构造器
class 类名 private[包名] (var i: Int) { } //该类只能被本包或子包类调用
13.特性
实现接口用 extends ,如果多个后面用 with
object:静态对象、单例对象、伴生对象
extends App //继承App对象不用写main方法
match匹配:
object Test {
def main(args: Array[String]) {
println(matchTest(3))
def matchTest(x: Int): String = x match {
case 1 => "one"
case 2 => "two"
case _ => "many"
}
}
:: 代表拼接 val list = "Facebook" :: ("Taobao" :: Nil)
case class;case object;类对象可以模式匹配
Option 子类 final case class Some 和 case object None,Map[Int].get(“key”)返回对象是option
14.并行计算
list.par //
list.aggregate(0)(_+_.sum, _+_)