Scala学习笔记

Scala学习笔记

一.Scala中集合的常用方法

首先定义两个数组集合，用于测试：

scala> val arr1 = Array(1,2,3,4)
arr1: Array[Int] = Array(1, 2, 3, 4)

scala> val arr2 = Array(3,4,5,6)
arr2: Array[Int] = Array(3, 4, 5, 6)

1.union并集

scala> val result = arr1.union(arr2)
result: Array[Int] = Array(1, 2, 3, 4, 3, 4, 5, 6)

2.intersect交集

scala> val result = arr1.intersect(arr2)
result: Array[Int] = Array(3, 4)

3.diff差集

scala> val result = arr1.diff(arr2)
result: Array[Int] = Array(1, 2)

二.并行化集合(多线程)

1.par并行化集合【好像windows中不能运行？难道windows中的scala不支持多线程？】

scala> val arr =Array(1,2,3,4,5)
arr: Array[Int] = Array(1, 2, 3, 4, 5)

scala> arr.par.reduce(_+_)
res0: Int = 15

可以看出真是因为多线程的原因，导致计算结果并不相同：

scala> arr.par.fold(10)(_+_)
res8: Int = 55

scala> arr.par.fold(10)(_+_)
res9: Int = 65

静态对象

1.在Scala中，静态对象就是用object修饰的对象，静态对象也叫做单例对象，因为其只有一份实例。使用代码验证如下：

object SingleObject {
  def main(args:Array[String]): Unit ={
    val o1 =  SingleObject//scala中直接使用这种方法即可得到单例对象
    val o2 =  SingleObject
    println(o1.toString)
    println(o2.toString)
    println(o1 == o2)//true
  }
}

2.定义在静态对象中的方法/变量都是静态方法/变量
3.当这个静态对象和类名相同，且在同一个文件中时，这个对象称之为该类的伴生对象
4.在scala中，文件名和类名可以不同
5.val var private private[this]修饰的变量的区别

• val修饰的变量，不可更改
• var修饰的变量，可以继续更改
• private修饰的变量，该类的伴生对象中可以继续访问
• private[this]修饰的变量，只能在该类的内部使用，即使在该类的伴生对象中都不能访问到

2.scala中类的构造器

• 主构造器——直接放在类名的后面，用括号将参数括起来

object Person {
  def main(args:Array[String]): Unit ={
    val o1 =  new Person(20,"LittleLawson")//scala中直接使用这种方法即可得到单例对象
    println("age:"+ o1.age+"\nname:"+o1.name)
  }
}
class Person(val age: Int,val name:String){
  println("执行主构造器")
}

• 辅助构造器
  辅助构造器必须满足以下几个条件：
  （1）必须先调用主构造器，
  （2）辅助构造器的参数必须多于主构造器，否则调用辅助构造器毫无意义

object Person {
  def main(args:Array[String]): Unit ={
    val o1 =  new Person(20,"LittleLawson","male")//scala中直接使用这种方法即可得到单例对象
    println("age:"+ o1.age+"\nname:"+o1.name+"\ngender:"+o1.gender)
  }
}
class Person(val age: Int,val name:String){
  var gender : String = null//这里必须写明gender的初始值为null
  def this(age:Int,name:String,gender:String){//调用辅助构造器
    this(age,name)
    this.gender = gender//赋值操作
  }
  println("执行主构造器")
}

6.继承APP(trait)

object Person extends  App {
  print("I can print hello without main function but extends App")
}

不用再写main方法，可以直接执行print()方法，因为这个App父类已经定义了main方法，而Person直接继承。

7.object中的apply()方法

object MyArray{
 def apply(str :String ):Unit={
    println(str)
 }

 def main(args :Array[String]):Unit = {
    val m = MyArray("LittleLawson")
    println(m)
 }
}

• 1） 如果在这个MyArray()中没有构造函数，那么就会找到与之参数相对应的apply方法，然后调用输出。
• 2）object是不能写构造参数的
• 3）val m1 = MyArray 直接获取Myarray的单例

8.在一个object中可以调用另外一个object中的静态方法或者是静态属性

object MyArray{
  def main(args :Array[String]):Unit = {
    println("his name is " + two.name)
    two.printTwo()
  }
}

object two{
  val name = "LittleLawson"
  def printTwo(): Unit ={
    println("I'm a function in object two")
  }
}

9.静态对象和类的区别
val a1 = Array(1,2,3,4,5) --->这里的Array就是静态对象
val a2 = new Array[Int](3) --->这里的Array就是类
10.trait：scala中的特质，相当于java8中的接口，抽象类和特质有啥区别？【待整理】