Scala语法
1.值和变量
val 值,不能发生变化
var 变量,可以发生变化
scala> val a:Int = 1
a: Int = 1
scala> a = 2;
<console>:12: error: reassignment to val
a = 2;
^
scala> var a:Int = 2
a: Int = 2
scala> a = 3
a: Int = 3
2.值和变量
object //伴生对象,相当于静态类
3.Range变量
1 to 10 1.to(10) immutable包下面都是不可变的:scala.collection.immutable.Range.Inclusive
1 until 10:数组遍历
Range(1,10,2)第三个参数是步长
for(i <- 1 to 5) {println(i)};
scala> 1 to 10
res0: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8,
9, 10)
scala> 1.to(10)
res1: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8,
9, 10)
scala> 1 until 10
res2: scala.collection.immutable.Range = Range(1, 2, 3, 4, 5, 6, 7, 8, 9)
scala> Range(1,10,2)
res3: scala.collection.immutable.Range = Range(1, 3, 5, 7, 9)
4.懒加载
lazy val a = 1;
5.变长参数
scala> def add(x:Int*){
| for(i <- x)
| println(i)
| }
add: (x: Int*)Unit
scala> add(3,5,6)
3
5
6
6.键值对参数,Map类型
scala.collection.mutable.Map
val m = Map(“k1”->1, “k2”->2)
m.get(“k1”) :有值为Some,没值为None
m(“k1”):
m.getOrElse(“1”, “None”): Any是Object、常用类型的父类。AnyRef是对象类型的父类
m+=(“k3”->3);
m -=(“k3”)
for((_:v)<-m){
println(v)
}
scala> val m = scala.collection.mutable.Map("K1"->1, "K3"->3)
m: scala.collection.mutable.Map[String,Int] = Map(K1 -> 1, K3 -> 3)
scala> m+=("K2"->2)
res11: m.type = Map(K1 -> 1, K3 -> 3, K2 -> 2)
7.元祖类型
val t = (1,2,”3”, 4);
下标访问,从1开始:t._1,t._3
val a= Array(1,2,3,4) //数组类型
下标访问,用小括号:a(0)
a++=Array(65,5,57,32)
a.remove(1,4)
scala> val t = (1,2,3,4)
t: (Int, Int, Int, Int) = (1,2,3,4)
scala> val t = (1, 3, 2, "4")
t: (Int, Int, Int, String) = (1,3,2,4)
scala> t._4
res12: String = 4
scala> t._2
res13: Int = 3
scala> val a = Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)
scala> val a = Array(1,2,"3",4)
a: Array[Any] = Array(1, 2, 3, 4)
scala> t(3)
<console>:13: error: (Int, Int, Int, String) does not take parameters
t(3)
^
scala> a(3)
res15: Any = 4
scala> a(2)
res16: Any = 3
8.对象
class Person{
var name:String = _ //需要有下划线
var age = 18
private[this] val xx = "xxxx" //即便是实例,也不能访问
}
class Person(val name:String, val age:Int){
println("主构造器")
var xx: String = _
def this(name:String, age:Int, xx:String){
this(name, age)
this.xx = xx
}
override def toString:String="xxxx" //重写父类方法
}
//如果不写var、val的话,默认为private[this]
9.接口、特质trait
trait Logger{//特质
}
//当一个类没有继承其他类是,可以用extends,有继承其他类时,用with
trait ConsoLogger extends Logger{
}
//特质是从左到右构造出来的,已经构造就不会再构造
10.apply()方法
import java.util._ //下划线_相当于jav里面的*
//对象加(),调用的是object的apply方法
//对象名加(),调用的是class的apply方法
class AT{
def test = "xxxx"
def apply()="~~~~"
}
object AT{
def apply() = "csddsf"
}
object Demo2 {
def main(args: Array[String]): Unit = {
var at = new AT();
println(AT());
println(at());
}
}
11.spark基本不用try catch
12.模式匹配,相当于switch case
object Demo3 {
//打印出一个变量的类型
def m(x:Any)=x match{
case o:Int => "int"
case o:String => "String"
}
def main(args: Array[String]): Unit = {
val x = 2
val result = x match{
case 1 => "one"
case 2 => "two"
case _ => "none"
}
println(result)
println(m(2));
println(m("hello"))
}
}
13.case类
absract class P0001
case class S0001(name:String) extends P0001
case class T0001(name:String) extends P0001
def ma(p:P0001) = {
p match {
case S0001(_) => "stu" //_匹配任意类型
case T0001(_) => "tea"
case _=>"None"
}
}
main{
println(ma(S0001("stu"))); //case类不用new字段
}
14.文件流
object FileIO {
def main(args: Array[String]): Unit = {
val file = Source.fromFile(new File("D:/data.txt"))
for(line <- file.getLines()){
println(line)
}
}
}
15.值函数
def add(x:Int, y:Int)={x+y} :
val add = add :将函数赋别名
_add: (Int, Int) => Int =
scala> def add(x:Int, y:Int) = {x+y}
add: (x: Int, y: Int)Int
scala> add(2,3)
res0: Int = 5
scala> val _add = add_
<console>:11: error: not found: value add_
val _add = add_
^
scala> val _add = add _
_add: (Int, Int) => Int = <function2>
16.函数嵌套函数
object Basic9 {
def add3(x:Int, y:Int, z:Int)={
def add2(x:Int, y:Int)={
x+y
}
add2(add2(x,y),z)
}
def main(args: Array[String]): Unit = {
println(add3(1,2,3))
}
}
17.匿名值函数
(x:Int)=>x+1
Int => Int =
scala> (x:Int)=>x+1
res1: Int => Int = <function1>
scala> res1(3)
res2: Int = 4
18.map函数
a.map()前面里面的每一个元素取出来,执行里面的function
a.map((x:Int)=>x*2) 匿名函数—-》去掉函数类型 —->
a.map((x)=> x*2)
a.map(_*2)
scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)
scala> a.map((x:Int)=>x*2)
res3: List[Int] = List(2, 4, 6, 8)
scala> a.map((x) => x*2)
res4: List[Int] = List(2, 4, 6, 8)
scala> a.map(_*2)
res5: List[Int] = List(2, 4, 6, 8)
scala> def add(x:Int)=x*2
add: (x: Int)Int
scala> a.map(add)
res6: List[Int] = List(2, 4, 6, 8)
19.type代表返回自身
有点糊涂
scala> (x:Int, y:Int) => Int
res3: (Int, Int) => Int.type =
scala> (x:Int, y:Int) => Int
res7: (Int, Int) => Int.type = <function2>
scala> res7(3,4)
res8: Int.type = object scala.Int
20.函数的参数是函数,确定了参数值,对参数的功能有参数函数确定
def fun(f:(Int, Int)=>Int):Int=f(3,4)
def add(x:Int, y:Int)=x+y
scala> def fun(f:(Int,Int)=>Int):Int=f(3,4)
fun: (f: (Int, Int) => Int)Int
scala> def add(x:Int, y:Int) = x+y
add: (x: Int, y: Int)Int
scala> fun(add)
res10: Int = 7
21.由一个函数生成另一个函数
def a(x:Int)=(y:Int)=>x+y
scala> def a(x:Int)=(y:Int)=>x+y
a: (x: Int)Int => Int
scala> a(2)
res11: Int => Int = <function1>
scala> res11(5)
res12: Int = 7
scala> a(4)(9)
res14: Int = 13