scala基础教程

目录

1 if 

2 for

3 while

4 元组 Tuple

4.1 定义方式

4.2 取值

4.3 对偶元祖

4.4 元组交换swap

5 数组Array

6 序列List

6.1 不可变序列

6.2 可变序列(需导包)

7 Map映射

7.1 不可变集合

7.2 可变集合

7.2.1 创建集合

7.2.2 添加元素

7.3 取值

7.4 遍历

7.5 获取keys和values

8 Set

8.1 不可变set

8.2 可变set

9 伴生对象

10 构造方法

---

1 if 

package com.weiyi.scala

object IfTest {
  def main(args: Array[String]): Unit = {
    val i = 2
    val y = if (i > 1){
      i
    } else {
      0
    }
    println(y)
  }

}

2 for

package com.weiyi.scala
 
object ForTest {
  def main(args: Array[String]): Unit = {
 
    var arr = Array("a","b","c")
    for (i <- arr){
      println(i)
    }
    for (b <- 1 to 6){
      println(b)
    }
 
    for (a <- 1 until 6){
      println(a)
    }
  }
 
}

3 while

package com.weiyi.scala
 
import scala.util.control.Breaks
 
object WhileTest {
  def main(args: Array[String]): Unit = {
    val loop: Breaks = new Breaks
    var i = 0
    while (i < 5){
      println(i)
      i += 1
      if (i == 3){
        loop.break()
      }
    }
  }
 
}

4 元组 Tuple

元组没有可变和不可变之分。 都是不可变的。

元组，是封装了一系列元素的集合。

元组是使用频率最高的。

4.1 定义方式

定义一： val tp1 = (1,100,true,”error”)

定义二： val tp2 = new Tuple3(1,100,true)  //3 代表元素的个数，必须和元素个数匹配。

4.2 取值

通过角标  角标从1开始

形式： tp1._1

package com.weiyi.scala
 
object TupleTest {
 
  def main(args: Array[String]): Unit = {
 
    val tp1 = ("1",2,true)
    println(tp1._1)
    
  }
 
}

4.3 对偶元祖

只有2个元素的元组，就称之为对偶元组

Map底层的每一组元素（k,v），都是一个对偶元组。（Map是由对偶元组组成的）

4.4 元组交换swap

scala> tp2
res17: ((String , Int) = (a,100)
 
scala> tp2.swap
res18: (Int, String) = (100,a)

元组的元素的个数：上限22个。new Tuple22(xxxx)

5 数组Array

package com.weiyi.scala
import scala.collection.mutable.ArrayBuffer
object ArrayTest {
  def main(args: Array[String]): Unit = {
 
    //定长数组
    //指定数组类型，并赋值，类型可省略，编译器会自动推导。
    //注意：如果不是 new，相当于调用了数组的 apply 方法，直接为数组赋值
    val arr1: Array[Int] = Array[Int](1,2,3)
    //通过 new 关键字创建的数组，必须指定数组的类型和长度
    val arr2: Array[Int] = new Array[Int](10)
    //取值赋值，下标从 0 开始：
    println(arr1(0))
 
    //变长数组  引入import scala.collection.mutable.ArrayBuffer
    val ab: ArrayBuffer[Int] = ArrayBuffer[Int](1,3,4)
    val ab2 = new ArrayBuffer[Int]()
    //向数组缓冲的尾部追加一个元素
    // += 尾部追加元素
    ab += 1
    //追加多个元素
    ab += (2,3,4)
    ab -= (3,4)
 
    //追加一个数组
    ab ++= Array(7,8)
    //追加一个数组缓冲
    ab ++= ArrayBuffer(9,0)
 
    //在数组某个位置插入元素用insert,第一个参数为插入元素的位置，后面的可变参数为插入的元素
    ab.insert(0, -1, 0)
    //删除数组某个位置的元素用remove，第一个参数为要删除的元素位置，第二个参数为删除几个元素
    ab.remove(8, 2)
 
    // 清空
    ab.clear()
    println(ab)
  }
}

6 序列List

不可变 list  长度不可变 ，内容也不可变  List

可变list    长度和内容都可变   ListBuffer

6.1 不可变序列

默认就是不可变序列，长度和内容都不可变，构造列表的两个基本单位是 Nil 和 ::  （Nil表示一个空列表）

创建List集合的两种方式:

package com.weiyi.scala
 
object ListTest {
 
  def main(args: Array[String]): Unit = {
 
    val list1: List[Int] = List[Int](1,2,3)
     val list2: List[Int] = 9::5::2::Nil
  }
}

注意： ::操作符是右结合的，该操作符就是将给定的头和尾创建一个新的列表

如 9::5::2::Nil 相当于9::(5::(2::Nil))

注意：在scala中列表要么为空，要么是一个head元素加上一个tail列表

对于不可变List的所有操作，全部生成新的List

package com.weiyi.scala
 
object ImmutListTest {
 
  def main(args: Array[String]): Unit = {
    //创建一个不可变的集合
    val lst1 = List(1,2,3)
    //将0插入到lst1的前面生成一个新的List
    val lst2 = 0::lst1
    val lst3 = 0+:lst1
    //将一个元素添加到lst1的后面产生一个新的集合
    val lst6 = lst1:+3
    val lst0 = List(4,5,6)
    //将2个list合并成一个新的list
    val lst7 = lst1 ++ lst0
    val lst8 = lst1 ++: lst0
    val lst9 = lst1 ::: lst0
    val lst11 = List.concat(lst1,lst0)
    //列表反转
    lst1.reverse
    //列表头元素
    val head: Int = lst1.head
    //列表的尾元素
    val tail: List[Int] = lst1.tail
  }
}

6.2 可变序列(需导包)

import scala.collection.mutable.ListBuffer

创建ListBuffer的两种方式

package com.weiyi.scala
import scala.collection.mutable.ListBuffer
object MutListTest {
 
  def main(args: Array[String]): Unit = {
 
    //创建ListBuffer的两种方式
    val lb1: ListBuffer[Int] = ListBuffer[Int]()//创建的同时可赋初始值
 
    val lb2: ListBuffer[Int] = new ListBuffer[Int]()//类型必须显示指定
  }
}

 

添加元素： +=方法和append方法，都可以添加多个元素 

package com.weiyi.scala
import scala.collection.mutable.ListBuffer
object MutListTest {
 
  def main(args: Array[String]): Unit = {
 
    val lst0: ListBuffer[Int] = ListBuffer[Int](1,2,3)
    val lst1: ListBuffer[Int] = new ListBuffer[Int]()
    //向lst1中追加元素 注意：没有生成新的集合
    lst1+=(3,4)
    lst1.append(5)
    
    //将lst0和lst1合并成一个新的ListBuffer  注意:生成了一个新的集合
    val lst2 = lst0 ++ lst1
  }
}

注:

可变list可以通过toList方法，生成新的List

list可以通过toBuffer，转变成ListBuffer

7 Map映射

在scala中，有2种map，一个是immutable包下的Map，该Map中的内容不可变，一个是mutable包下的Map，该Map中的内容可变

7.1 不可变集合

默认是immutable包下的Map

package com.weiyi.scala
 
object MapTest {
 
  def main(args: Array[String]): Unit = {
 
    val mp1: Map[String, Int] = Map(("a",1),("b",2))
    val mp2: Map[String, Int] = Map("a"->1,"b"->2)
    //添加元素之后生成新的map
    val mp3: Map[String, Int] = mp2+("c"->3)
  }
}

7.2 可变集合

7.2.1 创建集合

package com.weiyi.scala
 
import scala.collection.mutable
 
object MapTest2 {
 
  def main(args: Array[String]): Unit = {
 
    val mp4 = new mutable.HashMap[String,Int]()
    val mp5: mutable.Map[String, Int] = mutable.Map[String,Int]()
 
  }
}

7.2.2 添加元素

package com.weiyi.scala
 
import scala.collection.mutable
 
object MapTest2 {
 
  def main(args: Array[String]): Unit = {
 
    val mp4 = new mutable.HashMap[String,Int]()
    mp4 += ("e"->8,"f"->9)
    mp4 += (("b1",12))
    mp4.put("ly",56)
    mp4("zx") = 24
    
  }
}

7.3 取值

    mp4("a")
    mp4.get("xxyy")
    //如果没有值，赋予默认值：
    mp4.getOrElse("xxyy",9876)

7.4 遍历

   for (i <- mp4){
      println(i)
    }
    for ((k,v) <- mp4){
      println(k)
    }
    //_是占位符，如果只需要遍历value，可以使用占位符
    for ((_,v) <- mp4){
      println(v)
    }

7.5 获取keys和values

    val keys: Iterable[String] = mp4.keys
    val values: Iterable[Int] = mp4.values

8 Set

8.1 不可变set

长度和值都不可变，set中的元素不能重复

package com.weiyi.scala
 
object ImmutSetTest {
  def main(args: Array[String]): Unit = {
 
    //默认是immutable包下的Set
    val set1: Set[Int] = Set(1,2,3)
 
    //执行添加 删除的操作  都是生成了新的Set集合
    val s2: Set[Int] = set1 + (10,12)
    val s3: Set[Int] = set1 - (1)
    println(set1)
 
  }

8.2 可变set

可变Set中，remove方法，移除的是元素，而不是下标

package com.weiyi.scala
import scala.collection.mutable
object MuSetTest {
 
  def main(args: Array[String]): Unit = {
 
    val mSet: mutable.HashSet[Int] = new mutable.HashSet[Int]()
    val mutableSet = mutable.Set(1,2,3)
    mutableSet.add(4)
    mutableSet += (7,8)
    mutableSet ++= mutable.Set(12,34)
    mutableSet -= (3,2)
    //remove方法  删除的不是下标  而是元素
    mutableSet.remove(2)
    println(mutableSet)
    //转为不可变集合
    val an: Set[Int] = mutableSet.toSet
    
  }
}

9 伴生对象

伴生对象是一种特殊的单例对象，是一种相对概念，需要满足两个条件:

a.在同一个源文件中   b.对象名和类名相同

这样的单例对象，被称作是这个类的伴生对象，类被称为是这个单例对象的伴生类

结论：类和伴生对象之间可以相互访问私有的方法和属性

package com.weiyi.scala
 
class People {
  val id = 1
  private  var name = "lll"
  def prntName()={
    println(People.von + name)
  }
}
 
object People{
  //伴生对象中的私有属性
  private  val von = "aa"
  def main(args: Array[String]): Unit = {
    val p = new People()
    //访问私有的字段 name
    p.name = "123"
    p.prntName()
  }
  
}

10 构造方法

构造器分为两类：主构造器和辅助构造器，主构造器直接在类名后面定义，每个类都有主构造器，主构造器的参数直接放置类名后面，与类交织在一起，如果没有定义构造器，类会有一个默认的空参构造器

辅助构造器定义，使用def this关键字，而且必须调用主构造器，或者其他的辅助构造器

注意：主构造器会执行类定义中的所有语句
 

package com.weiyi.scala
 
 
//每个类都有主构造器，主构造器的参数直接放置类名后面，与类交织在一起
class Person(val name:String,val age:Int){
  //主构造器会执行类定义中的所有语句
  println("执行主构造器")
  private  var gender = "male"
  //用this关键字定义辅助构造器
  def this(name: String,age:Int,gender:String){
    //每个辅助构造器必须以主构造器或其他的辅助构造器的调用开始
    this(name,age)
    println("执行辅助构造器")
    this.gender = gender
  }
  private  var height = 175
 /* def this(name: String,age:Int,gender:String,height:Int){
    //每个辅助构造器必须以主构造器或其他的辅助构造器的调用开始
    this(name,age,gender)
    println("执行辅助构造器")
    this.gender = gender
    this.height = height
  }*/
}
 
object Person {
 
  def main(args: Array[String]): Unit = {
    val person: Person = new Person("a",12)
    val person2: Person = new Person("a",12,"333")
 
  }
}