Scala语言基础

/**
      * 块表达式
      */

    val a = 10

    val b = 20

    val result = {
      val c=b-a

      val d=b-c
      //块中最后一个表达式的值
      d
    }
    println(result)

结果：

10

 //for循环
    for (i <- 1 to 10)
      println(i)

    //for数组
    val arr = Array(1,2,3,4)

    for(i <-arr)
      println(i)


    //高级fro循环
    for(i <- 1 to 3;j <- 1 to 3 if i !=j)
      print(10*i+j+" ")
      println()

    //for推导式，如果for循环体一yield
    val  v = for(i <- 1 to 3) yield i*10
    println(v)

结果：

1
2
3
4
5
6
7
8
9
10
1
2
3
4
12 13 21 23 31 32 
Vector(10, 20, 30)

 //调用方法和函数
    def ml(x:Int,y:Int):Int=x*y

    //递归函数必须给出返回值类型
    def m2(x:Int,y:Int):Int={
      if (x<=1) 1
      else m2(x-1,y)*x
    }

    println(ml(1,2))

    println(m2(3,1))

    //定义函数
    //方法转化为函数参数是固定的函数是改变的
    val f1 = (x:Int,y:Int) => x+y


    def m3(f:(Int,Int)=>Int) = f(2,6)
    println(m3(f1))

    //神奇下划线将m1这个方法变成函数

    def m4(x:Int,y:Int) : Int =x*y

    val f2 = m4 _



    println(f2(2,3))

结果：

2
6
8
6

数组、映射、元组、集合

//数组
//1.定义定长数组
    var arr = new Array[Int](10)
    //2.定义变长数组

    var arr2= ArrayBuffer[Int]()
    println(arr2.toBuffer)
    //toBuffer将素组转换为长数组缓冲
    println(arr.toBuffer)
    val arr3 = Array("hadoop","Storm","abd")

    println(arr3(2))

    arr2+=1

    println(arr2.toBuffer)

    arr2+=(2,3,4)

    println(arr2.toBuffer)

    //追加一个数组
    arr2++=Array(6,7)

    println(arr2)

    //追加一个数组缓冲

    arr2++=ArrayBuffer(8,9)

    println(arr2)


    //val arr没有一下方法
    //在数组的某个位置插入元素，从某下标开始
    arr2.insert(2,12,13,14)

    println(arr2)

    //删除某个位置上的元素第一位表示开始，第二位表示个数
    arr2.remove(1,3)

    println(arr2)

结果：

ArrayBuffer()
ArrayBuffer(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
abd
ArrayBuffer(1)
ArrayBuffer(1, 2, 3, 4)
ArrayBuffer(1, 2, 3, 4, 6, 7)
ArrayBuffer(1, 2, 3, 4, 6, 7, 8, 9)
ArrayBuffer(1, 2, 12, 13, 14, 3, 4, 6, 7, 8, 9)
ArrayBuffer(1, 14, 3, 4, 6, 7, 8, 9)

//遍历数组
 var arr21 = Array(1,2,3,4,5)

    //增强for循环

    for (i <-arr21)
      print(i+" ")

    //好用的until会生成一个Range
    //reverse是将前面生成的Range反转
    for (i<-(2 until arr21.length).reverse)
      print(arr21(i)+" ")

    //数组转化
    val arr22 =Array(1,7,5,4,6,3,2)

    //1.将偶数相乘
    val res = for (e <- arr22 if e % 2 ==0)
      yield e*10

    println(res.toBuffer)


    //2.高级写法
    //filter是过滤，接收一个返回值为boolean的函数
    //map相当于将数组中的每一个元素取出来，应用传进去的函数

    val r = arr22.filter(_ %2==0).map(_ *10)

    println(r.toBuffer)


    //数组常用算法
    println(arr22.sum)

    println(arr22.max)

    println(arr22.sorted.toBuffer)

结果：

1 2 3 4 5 5 4 3 ArrayBuffer(40, 60, 20)
ArrayBuffer(40, 60, 20)
28
7
ArrayBuffer(1, 2, 3, 4, 5, 6, 7)

//映射
    //1.第一种构建方式
    val scores= Map("tom"->12,"jerry"->13)

    println(scores)

    //1.第二种构建方式

    val scores2=Map(("tom",123),("jerry",133))

    //2.第二种构建方式
    println(scores2)

    //获取map中的值1.
    println(scores.get("tom"))

    //2.获取
    println(scores.getOrElse("tom1",22))

    //注意：在Scala中，有两种Map，一个是immutable包下的Map，该Map中的内容不可变；另一个是mutable包下的Map，该Map中的内容可变
    //scores +=("kitty"->22,"lili"->25) 不可用

    //在导入这个包之后创建的map才可用+=
    import scala.collection.mutable.Map

    //scores +=("kitty"->22,"lili"->25) 不可用

    val scores3 = Map("tom"->22)

    scores3+=("123"->123)

    println(scores3)

结果：

Map(tom -> 12, jerry -> 13)
Map(tom -> 123, jerry -> 133)
Some(12)
22
Map(tom -> 22, 123 -> 123)

/*
    *元组：
    * （1）元组是不同类型的值的聚集；对偶是最简单的元组。
    * （2）元组表示通过将不同的值用小括号括起来，即表示元组
     */
val tuple = ("hadoop",3.13,123213,Array(1,23,4))

    println(tuple._1)

    println(tuple._4.toBuffer)

结果：

hadoop
ArrayBuffer(1, 23, 4)

 /**
      * 将对偶的集合转化成映射
      */
     val array=Array(("tom",222),("jerry",33))

   var map=array.toMap

   println(map)

结果：

Map(tom -> 222, jerry -> 33)

/**
      * 拉链操作
      * 使用zip命令可以将多个值绑定在一起
      *
      */
    val scores = Array(88, 55, 22)

    val names = Array("tom", "jerry", "jack")
    //注意：如果两个数组的元素个数不一致，拉链操作后生成的数组的长度为较小的那个数组的元素个数
    var arr1 = names.zip(scores)

    println(arr1.toBuffer)

    //如果其中一个元素的个数比较少，可以使用zipAll用默认的元素填充

    val score1 = Array(88,55)

    val arr2 = names.zipAll(score1,"zhaoliu",100)

    println(arr2.toBuffer)

结果：

ArrayBuffer((tom,88), (jerry,55), (jack,22))
ArrayBuffer((tom,88), (jerry,55), (jack,100))

 /**
      * 集合
      * Seq、set、Map
      *
      */

    val lst1 = List(1,2,3)

    //补充：另一种定义list方法
    val other_lst=2::Nil

    //获取集合的第一个元素

    val head = lst1.head

    //获取集合除第一个袁术的其他袁术集合

    val tail = lst1.tail
    //补充：其中如果 List 中只有一个元素，那么它的 head 就是这个元素，它的 tail 就是 Nil；

    println(other_lst.head+"----"+other_lst.tail)

    val lst2 = 0::lst1

    val lst3 = lst1.::(0)

    val lst4 = 0 +: lst1

    val lst5 = lst1.+:(0)

    //将一个元素添加到lst1的后面产生一个新的集合
    val lst6 = lst1 :+ 3
    val lst0 = List(4,5,6)
    //将2个list合并成一个新的List
    val lst7 = lst1 ++ lst0
    //将lst0插入到lst1前面生成一个新的集合
    val lst8 = lst1 ++: lst0
    //将lst0插入到lst1前面生成一个新的集合
    val lst9 = lst1.:::(lst0)

    println(other_lst)
    println(lst1)
    println(head)
    println(tail)
    println(lst2)
    println(lst3)
    println(lst4)
    println(lst5)
    println(lst6)
    println(lst7)
    println(lst8)
    println(lst9)

结果：

2----List()
List(2)
List(1, 2, 3)
1
List(2, 3)
List(0, 1, 2, 3)
List(0, 1, 2, 3)
List(0, 1, 2, 3)
List(0, 1, 2, 3)
List(1, 2, 3, 3)
List(1, 2, 3, 4, 5, 6)
List(1, 2, 3, 4, 5, 6)
List(4, 5, 6, 1, 2, 3)

//构建一个可变列表，初始有3个元素1,2,3
  val lst0 = ListBuffer[Int](1,2,3)
  //创建一个空的可变列表
  val lst1 = new ListBuffer[Int]
  //向lst1中追加元素，注意：没有生成新的集合
  lst1 += 4
  lst1.append(5)

  //将lst1中的元素最近到lst0中， 注意：没有生成新的集合
  lst0 ++= lst1

  //将lst0和lst1合并成一个新的ListBuffer 注意：生成了一个集合
  val lst2= lst0 ++ lst1

  //将元素追加到lst0的后面生成一个新的集合
  val lst3 = lst0 :+ 5

  //删除元素,注意：没有生成新的集合
  val lst4 = ListBuffer[Int](1,2,3,4,5)
  lst4 -= 5

  //删除一个集合列表,生成了一个新的集合
  val lst5=lst4--List(1,2)

  //把可变list 转换成不可变的list 直接加上toList
  val lst6=lst5.toList

  //把可变list 转变数组用toArray
  val lst7=lst5.toArray

  println(lst0)
  println(lst1)
  println(lst2)
  println(lst3)
  println(lst4)
  println(lst5)
  println(lst6)
  println(lst7)

结果：

ListBuffer(1, 2, 3, 4, 5)
ListBuffer(4, 5)
ListBuffer(1, 2, 3, 4, 5, 4, 5)
ListBuffer(1, 2, 3, 4, 5, 5)
ListBuffer(1, 2, 3, 4)
ListBuffer(3, 4)
List(3, 4)
[I@79698539

val set = Set(1,2,3,4,5)

    println(set.size)

    println(set.min)


    println(set.max)

    val set1=set+8

    println(set1)

    val set2 = Set(7,8,9)
    //两个集合的交集
    val set3 = set & set2

    println(set3)
    //两个集合的并集
    val set4 = set++set2
    println(set4)

    //在第一个set的基础上去掉第二个set中存在的元素
    val set5 = set--set2

    println(set5)

    //返回第一个不同于第二个set的元素集合
    val set6 = set&~set1

    println(set6)

    //计算不符合条件的元素个数
    println(set.count(_>5))

    //返回不同于第二个元素的集合
    println(set.diff(set1))
    //取子set(2,5为元素位置, 从0开始，包含头不包含尾)
    println(set.slice(2,5))
    //迭代所有的子set，取指定的个数组合
    set.subsets(2).foreach(x=>println(x))

结果：

5
1
5
Set(5, 1, 2, 3, 8, 4)
Set()
Set(5, 1, 9, 2, 7, 3, 8, 4)
Set(5, 1, 2, 3, 4)
Set()
0
Set()
Set(2, 3, 4)
Set(5, 1)
Set(5, 2)
Set(5, 3)
Set(5, 4)
Set(1, 2)
Set(1, 3)
Set(1, 4)
Set(2, 3)
Set(2, 4)
Set(3, 4)

import scala.collection.mutable
    val set1=new mutable.HashSet[Int]()
    //添加元素
    set1+=1

    set1.add(3)

    //向集合中添加元素集合
    set1++=Set(23,2,5)

    //删除一个元素
    val bool = set1.remove(1)

    println(bool)

结果：

true

  val imap=Map("zhangsan" -> 20,"lisi" ->30)

    println(imap.keys)

    println(imap.keySet)

    println(imap("lisi"))

    //声明一个可变集合
    import scala.collection.mutable

    val user =mutable.HashMap("zhangsan"->50,"lisi" -> 100)

    user +=("wangwu" -> 30)

    user -=("zhangsan")

    //删除key
    user.remove("zhangsan0")

    //遍历map 方法一：通过key值
     for(x<- user.keys) println(x+" -> "+user(x))


    //遍历map 方法二：模式匹配
    for((x,y) <- user) println(x+" -> "+y)


    //遍历map 方法三：通过foreach
    user.foreach{case (x,y) => println(x+" -> "+y)}

结果：

Set(zhangsan, lisi)
Set(zhangsan, lisi)
30
lisi -> 100
wangwu -> 30
lisi -> 100
wangwu -> 30
lisi -> 100
wangwu -> 30

类

class Person {

  /**
    * 在Scala中，类并不用声明为public类型的。
    * Scala源文件中可以包含多个类，所有这些类都具有共有可见性。
    */

  //val修饰的变量是可读属性，有getter单没有setter（相当与Java中用final修饰的变量

  val id="9527"

  //用var修饰的变量都既有getter，又有setter

  var age:Int=18
  //类私有字段，只能在类的内部使用或者伴生对象中访问
  private var name : String = "唐伯虎"

  private[this] var pet ="小强"
}

object Person{
  def main(args: Array[String]): Unit = {
    val p=new Person

    println(p.id)

    println(p.age)
    //打印name,伴生对象中可以在访问private变量
    println(p.name)
    //由于pet字段用private[this]修饰，伴生对象中访问不到pet变量
    //p.pet(访问不到)


  }

}

构造器

class Student(val name:String,var age:Int) {

  //主构造器会执行类定义的所有语句
  println("执行主构造器")

  private var gender = "male"

  def this(name:String,age:Int,gender:String){
    this(name,age)

    println("执行赋值构造器")

    this.gender=gender
  }



}

object Student{

  def main(args: Array[String]): Unit = {
    val s1 = new Student("zhangsan",29)

    val s2 = new Student("zhangshan",33,"female")


  }
}

/*object作用：
1.存放工具方法和常量
2.高效共享单个不可变的实例
3.单例模式*/
class Session {}

object SessionFactory{
  //该部分相当于java中的静态块
  val  session=new Session

  //在Object中的方法相当于java中的静态方法

  def getSession():Session={
    session
  }

}

object SingletonDemo{
  def main(args: Array[String]): Unit = {
    //单例对象，不需要new，用【单例对象名称.方法】调用对象中的方法
    val session1 = SessionFactory.getSession()

    println(session1)
    //单例对象，不需要new，用【单例对象名称.变量】调用对象中成员变量
    val seession2 = SessionFactory.session

    println(seession2)
  }
}

伴生类，半生对象

/*如果有一个class文件，还有一个与class同名的object文件，那么就称这个object是class的伴生对象，class是object的伴生类；
伴生类和伴生对象必须存放在一个.scala文件中；
伴生类和伴生对象的最大特点是，可以相互访问；*/

//伴生类
class Dog {

  val id=1
  private var name="itcast"

  def printName():Unit={
    println(Dog.CONSTANT+name)

  }

}

//半生对象

object Dog{

  //伴生对象中的私有属性

  private val CONSTANT ="汪汪汪"

  def main(args: Array[String]): Unit = {
    val p = new Dog
    //访问私有的字段那么

    p.name="123"

    p.printName()
  }
}