https://www.runoob.com/scala/scala-install.html
IDEA创建Scala项目
基本与java类似，但首字符要大写
| 类型 | 说明 |
|---|---|
| Byte | -128-127 |
| Short | -32768-32767 |
| Int | -2147483648-2147483647 |
| Long | 64位 |
| Float | 32位单精度浮点数 |
| Double | 64位双精度浮点数 |
| Char | 16位无符号Unicode字符 |
| Boolean | true或者false |
| Unit | 等同void |
| Null | null或者空引用 |
| Nothing | 类的最底层 |
| String | 字符序列 |
| Any | 所有类的超类 |
Scala使用关键词 "var" 声明变量，使用关键词 "val" 声明常量，可以省略类型，会自动检测类型
val name = "song"; // 常量
var age = 18 // 变量
var num:Int = 10 // 变量
属性定义：类的括号里可以定义参数，但必须指明类型，格式val 参数名:类型或者var 参数名:类型，可以看到，类似于java的有参构造函数，有了参数就有了构造，默认有set和get方法，只有var变量可以set
方法声明：def functionName ([参数列表]) : [return type]
class Person (){
var name : String = _
var age : Int = _
println("1.父类的主构造器")
def this(name : String,age : Int){
this()
println("2.父类的辅助构造器")
this.name = name
this.age = age
}
def printInfo() = {
println(s"Person : $name,$age")
}
}
class Teacher(name : String,age : Int) extends Person(){
var address : String = _
println("3.子类的主构造器")
def this(name : String,age : Int,address : String){
this(name,age)
println("4.子类的辅助构造器")
this.address = address
}
override def printInfo() = {
println(s"Teacher : $name,$age,$address")
}
}
object PsersonDemo {
def main(args: Array[String]): Unit = {
val jack: Person = new Person("jack", 36)
println("=============================================")
val teacher: Teacher = new Teacher("rose", 30, "gz")
jack.printInfo()
teacher.printInfo()
}
}
枚举类
case class Schedule(name:String)
object Schedule{
val day = Schedule("day")
val hour = Schedule("hour")
}
在 Scala 中，是没有 static 这个关键字，但是它也为我们提供了单例模式的实现方法，那就是使用关键字object，object相当于java的单例，定义全是静态的
object Lesson_ClassAndObj {
val name = "static test" // 等同于java中用static声明的属性
def main(args: Array[String]): Unit = { // 主函数
val person = new Person("song", 24) // 对象
println(person.name); // get方法
println(person.age);
// 如果age是var类型 person.age = 18相当于调用set方法
person.sayName() // 调用方法
}
}
作用：实现类似Java中那种既有实例成员又有静态成员的类的功能，这样伴生对象中的属性或者方法就好像加上了一个java中static的关键字那样，可以通过类.属性或者类.method()
1.定义一个class并在这里面实现所有的实例成员
2.添加一个 object ，这个object 要与上面的class同名，然后在这里面实现所有的静态成员，也即伴生对象
3.定义的 class 与 object 必须在同一个文件内
当单例对象与某个类共享同一个名称时，他被称作是这个类的伴生对象：companion object。你必须在同一个源文件里定义类和它的伴生对象。类被称为是这个单例对象的伴生类：companion class。类和它的伴生对象可以互相访问其私有成员
apply()方法会帮助我们免除new关键字
// 普通类
class CompanionTest (val color : String) {
private val name: String = "Java"
def out(): Unit = { // 访问伴生对象的私有属性 object.属性
println("伴生对象的私有属性： " + CompanionTest.addrss)
}
}
// 伴生对象，与类名字相同，可以访问类的私有属性和方法
object CompanionTest{
private val addrss = "gz" // CompanionTest.address 等同于实现了java中的类.属性
// 伴生类的实例
private val companionTest: CompanionTest = new CompanionTest("red")
def out2(): Unit = {
println(companionTest.name) // 访问伴生类的私有属性 实例.属性
}
def apply(color: String): CompanionTest = new CompanionTest(color)
}
object Test{
def main(args: Array[String]): Unit = {
// 免new apply方法
val test: CompanionTest = CompanionTest("blue")
println(test.color)
test.out()
}
}
控制抽象 主要在在一个方法中调用某个代码块 也没有返回值
object OpTest {
def main(args: Array[String]): Unit = {
// 柯里化
def a (name : String)(op : => Unit): Unit ={
println("我是控制抽象op前的操作" + "名字"+name)
op
println("我是控制抽象op后的操作" + "名字"+name)
}
// 方法中的代码块将作为op
a("zhang"){
println("我是op")
}
}
}
object IfElse {
def main(args: Array[String]): Unit = {
var x = 30;
if (x == 10) {
println("X 的值为 10");
} else if (x == 20) {
println("X 的值为 20");
} else if (x == 30) {
println("X 的值为 30");
} else {
println("无法判断 X 的值");
}
}
}
object Circle {
def main(args: Array[String]): Unit = {
for(num <- 1 to 10){ // 1到10，包括10
print(num+"-");
}
println()
for(num <- 1 until(10,2)){ // 10到9，步长为2
print(num+"-")
}
println()
for(num <- 1 to 10 ; if(num % 2 == 0) ; if(num > 5)){ // 可以加判断条件
print(num+"-")
}
println()
// 局部变量
var a = 1
// do 循环
do {
print("Value of a: " + a +"-")
a = a + 1
} while ( {
a < 3
})
}
}
def functionName ([参数列表]) : [return type]
object Method {
def main(args: Array[String]): Unit = {
def max(a:Int,b:Int):Int = {
if(a > b) return a;
else return b;
}
// def max(a:Int,b:Int):Int = {
// if(a > b) a else b;
// }
val result : Int = max(100,20);
println(result)
}
}
递归方法
递归方法必须指定返回值类型
def fun(num:Int):Int = {
if(num == 1) return 1
else return num * fun(num - 1)
}
println(fun(5))
有参数默认值的方法
def fun(a:Int=10,b:Int=20) = {
a + b;
}
println(fun()) // 不覆盖
println(fun(100,300)) // 全部覆盖
println(fun(100)) // 覆盖a
println(fun(b = 50)) // 覆盖b
可变长参数的方法
def fun(s:String*)={
s.foreach(elem=>{println(elem)})// 两种输出方式
for(string <- s) println(string)
}
fun("zhang","liu","wang")
匿名函数
=>就是匿名函数
def fun = (a:Int,b:Int)=>{
a+b
}
println(fun(1,6))
嵌套
def fun(a:Int): Int ={
def fun1(b:Int): Int ={
if(b == 1) 1
else b * fun1(b - 1)
}
fun1(a)
}
println(fun(5))
偏应用函数
def show(date:Date,log:String)={
println(s"date is $date,log is $log") // s $引用外部的属性
}
def fun = show(date = new Date(),_:String) // _ 占位符
fun("a")
fun("b")
fun("c")
方法参数是函数
类型指定(Int,Int) =>Int
def fun(f:(Int,Int)=>Int,s:String):String={
val res:Int = f(100,200)
res + ""+s
}
val result = fun((a:Int,b:Int)=>{a*b},"scala")
println(result)
返回值是函数
def fun(s:String):(String,String)=>String={
def fun1(s1:String,s2:String):String={
s + s1 + s2
}
fun1
}
println(fun("zhang")("liu","wang"))
方法参数和返回值都是函数
def fun(f:(Int,Int)=>Int,s:String):(String,String)=>String={
val a:Int = f(100,200)
def fun1(s1:String,s2:String):String={
s1+s2+s+a.toString
}
fun1
}
val res = fun((a:Int,b:Int)=>{a+b},"hello")("zhang","kun")
println(res)
柯里化函数
def fun(a:Int,b:Int)(c:Int,d:Int)={
a+b+c+d
}
println(fun(1,2)(3,4))
object StringTest {
def main(args: Array[String]): Unit = {
val s = "zhang" // 普通字符串
val s1 = "zhang1"
val sb = new StringBuffer(); // 可变字符串
sb.append(s).append("liu")
println(sb)
val i = s.compareTo(s1) // compareTo
println(i)
println(s1.charAt(1)) // 索引
val chars = s.toCharArray // 字符串转数组
chars.foreach(c=>{print(c+" ")})
}
}
object ArrayTest {
def main(args: Array[String]): Unit = {
val array = Array[String]("ab","bc") // 直接赋值
array.foreach(s=>{print(s + " ")})
println()
val array2 = new Array[Int](3) // 先声明再赋值，new不可以省略
array2(0) = 2
array2(1) = 3
array2(2) = 10
array2.foreach(num=>{print(num + " ")}) // 遍历数组
println()
val array3 = new Array[Array[Int]](3) // 二维数组 三行
array3(0) = Array[Int](1,2,3,8)
array3(1) = Array[Int](1,6,2)
array3(2) = Array[Int](8,12,9)
array3.foreach(arr=>{arr.foreach(num=>{print(num+" ")});println()}) // 遍历二维数组
var myList1 = Array(1.9, 2.9, 3.4, 3.5) // 合并数组
var myList2 = Array(8.9, 7.9, 0.4, 1.5)
var myList3 = Array.concat(myList1, myList2)
// 输出所有数组元素
for ( x <- myList3 ) {
print( x + " ")
}
println()
var myArr = Array.range(10,20)// 区间数组
myArr.foreach(num=>{print(num+" ")})
}
}
List
实际开发使用ListBuffer较多，创建时不使用new关键字，可以初始化ListBuffer，例如
ListBuffer[String](“kun”,“zhang”)
object ListTest {
def main(args: Array[String]): Unit = {
val list: List[String] = List[String]("hadoop", "spark")
// List添加元素到最前面 注意 List是不可变的，这里只是生成了新的一个List了 List(brfore, hadoop, spark)
println(list.+:("brfore") )
// List添加元素到最后面 List(hadoop, spark, after)
println(list :+ "after")
val newList = list.+:("before")
// 连接两个List List(hadoop, spark, before, hadoop, spark)
println(list ::: newList)
val list2: ListBuffer[Int] = ListBuffer[Int]() // 可变ListBuffer
list2.append(66) // append添加元素
list2.append(33,66,66,99) // append批量添加
40 +=: list2 // +=: 加到前面
println(list2) // ListBuffer(40, 66, 33, 66, 66, 99)
list2 -= 66 // -=删除已知元素
list2.remove(2) // 删除下标为index的元素
list2.update(3,1000) // 改元素 index,new data
println(list2(0)) // 根据索引查元素 40
}
}
Set
object SetTest {
def main(args: Array[String]): Unit = {
val set = Set[Int](1,2,2,2,3,4,5)
val set1 = Set[Int](4,5)
set.foreach((num)=>print(num+" ")) // set有去重功能
println()
val ints = set.intersect(set1) // 集合差集 也可以 set & set1
val ints1 = set.diff(set1) // 差集
val set2 = mutable.Set[Int](1,2,3) // 可变set
set2 += 4
set2 -= 2
set2.foreach((num) =>{print(num+" ")})
println()
}
}
Map
object MapTest {
def main(args: Array[String]): Unit = {
val map = Map[String,Int]("aa"->20,("b",30),("b",40));
val value = map.get("aa").get // 获取value 20
for(elem <- map){ // 遍历map
println(elem)
}
map.foreach(kv=>{ // 遍历集合
println(kv)
})
val keys = map.keys // 获取所有键值
keys.foreach(key=>{ // 遍历key获取value
val value1 = map.get(key).get
println(s"key == $key,value = $value1")
})
val values = map.values // 获取所有value
val map1 = Map[String,Int]("aa"->20,("b",30),("c",40));
val map2 = Map[String,Int]("aa"->30,("b",40),("c",50));
val map3 = map1.++(map2) // map2替换map1
val map4 = map1.++:(map2) // map1替换map2
var map5 = Map[String,Int]() // 可变map
map5 += ("age" -> 20)
map5 += ("length" -> 40)
map5.foreach(println)
val map6 = mutable.Map[String,Int]() // 可变map
}
}
Tuple
object TupleTest {
def main(args: Array[String]): Unit = {
// 元组可以存不同类型的元素
val tuple = new Tuple1("zhang")
val tuple2 = new Tuple2("zhang",'C')
val tuple4 = new Tuple4("zhang", false, 'C', 16)
val value = tuple2._1 // ._xx取值
println(value)
val value1 = tuple4._4
println(value1)
val iterator = tuple4.productIterator // 遍历，只能先拿到迭代器
iterator.foreach(value=>{println(value)})
}
}
Scala Trait(特征) 相当于 Java 的接口，实际上它比接口还功能强大
与接口不同的是，它还可以定义属性和方法的实现
一般情况下Scala的类只能够继承单一父类，但是如果是 Trait(特征) 的话就可以继承多个，从结果来看就是实现了多重继承
Trait(特征) 定义的方式与类类似，但它使用的关键字是 trait
trait Audi{
val name = "Audi"
def runAudi(time:Int)={
println(name+"running....."+time)
}
}
trait Benz{
val name1 = "Benz"
def runBenz(time:Int)={ // 实现的方法
println(name1+"running....."+time)
}
def recreate():String // 未实现的方法
}
class Car extends Audi with Benz { // 继承第一个用extends，第二个用with
override def recreate(): String = {
"recreate.."
}
}
object TraitTest {
def main(args: Array[String]): Unit = {
val car = new Car
car.runBenz(10)
car.runAudi(20)
}
}
一个模式匹配包含了一系列备选项，每个都开始于关键字 case。每个备选项都包含了一个模式及一到多个表达式。箭头符号 => 隔开了模式和表达式
case _ 什么都不匹配
可以匹配类型，也可以匹配值
object MatchTest {
def main(args: Array[String]) {
println(matchTest("two"))
println(matchTest("test"))
println(matchTest(1))
println(matchTest(6))
println("偏函数"+myTest("ooo"))
}
def matchTest(x: Any): Any = x match {
case 1 => "one"
case "two" => 2
case y :Int => "scala.Int" // 匹配Int类型
case _ => "no match" // case _ 什么都不匹配,类似 switch 中的 default
}
def myTest:PartialFunction[String,Int] = { // 偏函数相比match没有match了，匹配String，返回Int
case "abc" => 22
case "bcd" => 66
case _ => 84
}
}
当我们定义一个样例类，编译器自动帮助我们实现了apply方法，无需new关键字，而且自动实现了以下的方法
toString方法：可直接调用
equals方法：可以直接使用==比较两个样例类是否相等，即所有的成员变量是否相等
hashCode方法：样例类自动实现了hashCode方法，如果所有成员变量的值相同，则hash值相同，只要有一个不一样，则hash值不一样
copy方法：样例类实现了copy方法，可以快速创建一个相同的实例对象，可以使用带名参数指定给成员进行重新赋值
使用了case关键字的类定义就是样例类(case classes)，样例类是种特殊的类，经过优化以用于模式匹配，默认有get和set（对var类型）方法
object CaseClass {
def main(args: Array[String]) {
val alice = Person("Alice", 25)
val bob = Person("Bob", 32)
val charlie = Person("Charlie", 32)
for (person <- List(alice, bob, charlie)) {
person match {
case Person("Alice", 25) => println("Hi Alice!")
case Person("Bob", 32) => println("Hi Bob!")
case Person(name, age) =>
println("Age: " + age + " year, name: " + name )
}
}
}
// 样例类
case class Person(name: String, age: Int)
}
部分参数是隐式参数，必须使用柯里化的方式
作用
当调用方法时，不必手动传入方法中隐式参数，Scala会自动在作用域内寻找隐式值并自动传入，所以在一个作用域内不能定义多个类型一样的隐式值
object ImplicitTrans {
def main(args: Array[String]): Unit = {
implicit val name:String = "zhang" // implicit声明隐式值柯里化的方式
def sayName(age:Int)(implicit name:String) ={ //
println(s"$name is student... age = $age")
}
sayName(10)
}
}
作用
实现类中方法的共享
class Red{
def sayWho()={
println("Red Red Red")
}
}
class Green{
}
object ImplicitTest {
implicit def greenToRed(green: Green):Red = { // 隐式函数
new Red
}
def main(args: Array[String]): Unit = {
val green = new Green
green.sayWho()
}
}
上面的例子中，创建了green对象，但我想用Red类中的方法，于是我就声明一个隐式函数，传入green对象，返回一个red对象，就可以调用了
注意：相同作用域内，不可以定义相同的传入参数和返回类型相同的隐式函数
class Dog{
}
object ImplicitClass {
implicit class Animall(dog: Dog){
def sayName(): Unit ={
println("dog隐式类...")
}
}
def main(args: Array[String]): Unit = {
val dog = new Dog
dog.sayName // 创建了一个dog对象
}
}
创建了一个dog对象，调用了sayName方法，但实际类中是没有这个方法的，于是就去找有没有一个隐式类，参数是Dog类型的，有的话就可以调用里面的方法