scala基础

并集    

"Hello".insertsect("World")

 scala基础操作

import scala.math._
object test {
  def main(args: Array[String]): Unit = {
    println(sqrt(2))
    println(pow(2,4))
    println(min(3,8))

    println(BigInt.probablePrime(4,scala.util.Random))
    //从2^4 和  2^(4-1)之间随机挑选一个素数

    println("hello".distinct)
    //和sqldistinct类似，保留单一字符

    //函数调用apply方法 调用语句是    def apply(n:int): Char
    print("hello".apply(3))
   //字符串转数字
    print(BigInt("45678"))

2.控制结构和函数

/**
  * Created with IntelliJ IDEA.
  * User: @别慌
  * Date: 2019-07-15
  * Time: 8:56
  * Description: 
  */
import scala.util.control.Breaks._
import scala.math._
object scala_test {
  def main(args: Array[String]): Unit = {

    /*
      scala if-else case
      val x =1
    val result =if (x>0) "bigger" else "small"
    print(result)
     */

    /*
    if-else if-else  case

    val x=9
    val re01=if (x>10) "more 10" else if(x>5) "big5" else "other"
    //如果if 后面为false 执行后面的 else if
    print(re01)
*/




    /*
    for (i<- 1 to 3;j<- 1 to 3 if i!=j) print((10*i+j)+" ")
     i  为  1，2，3
    j   为  1，2，3
    结果为 12 13 21 23 31 32
     */


    /*
    scala 中的 break
    import scala.util.control.Breaks._

    val x=10
breakable{
  for (i<- 0 to x){
    if (i==5){
      break;
    }
    print(i+" ")
  }

}
     */

/*
for 循环多生成器
 for (i<- 1 to 3;j<-1 to 3;if i!=j) print((10*i+j)+" ")

 result:  12 13 21 23 31 32
 */


    /*
    for 循环 生成新的 集合
    val Vector=for (i<- 1 to 10) yield i%3
    print(Vector)
     */

/*
  // 函数
    def abs01(x:Double)=if(x>=0) x else  -x  // must decalare type
    print(abs01(-10))
 */




    /*

  def fac(n:Int)={
      var r = 1
      for (i<- 1 to n) r =r + i
      r
    }
    print(fac(3)+" ")

    r  1   2   4
    i  1   2   3
    back    4+3=7
     */

/*
递归计算必须指定返回值类型
def fac(n:Int):Int=if (n<=0) 1
     else n * fac(n - 1)
     print(fac(3))
3*2*fac(1) = 6
let idea know the fac(n-1) type
 */


/*
默认参数   并不显式的指出参数值
 def decorate(str:String,left: String="[",right: String="]") =
    left+str+right
    print(decorate("hello,world"))
 */


    /*
    可变长函数

    def sum(args:Int*)={
      var result = 0
     for (arg<- args) result+=arg
      result
    }
    print(sum(3,2,1))     // 传入的是单数  而不是一个整数区间，解决办法
    print(sum(1 to 100:_*))
     */

    

  }
}

3.scala数组

/**
  * Created with IntelliJ IDEA.
  * User: @别慌
  * Date: 2019-05-31
  * Time: 8:41
  * Description: 
  */
import scala.math._
import scala.collection.mutable.ArrayBuffer
object test {
 def main(args: Array[String]): Unit = {
  //创建定长数组
  val nums = new Array[Int](10);
  val nums_1 = new Array[String](10);

  val s = Array("hello", "world","the","shy","faker","ruler")
  println("遍历数组所在的内存地址")
  println(nums)
  println(nums_1)
  println(s) //输出内存地址码，这里需要对数组进行遍历

  println("遍历数组第一种方式")
  for (inter <- s)  { //这里是遍历数组操作
   println(inter)
  }

   val  l=for (in <- s) yield  in+"  new_value "
  println("这里是数组转换为一个全新的数组")
  for (iop <- l)
   {
    println(iop)
   }

  println("遍历数组第二种方式并倒序输出")
  for (internet <- (0 to s.length - 1).reverse) {
   println(s(internet))
  }

  println("遍历数组第三种方式并每两个元素一跳")
  for (internet01 <- 0 until (s.length,2))  {
   println(s(internet01))
  }
   /*
 *
 */

   //创建变长数组 引用 数组包 import scala.collection.mutable.ArrayBuffer
   val b = ArrayBuffer[Int]()
   b += 1
   println("第一步结果,在尾端添加元素", b)
   b += (1, 2, 3, 5)
   println("第二步结果，在尾部添加多个元素", b)
   b ++= Array(8, 13, 21)
   println("第三步结果，追加任何集合", b)
   b.trimEnd(5)
   println("第四步结果，移除最后5个元素", b)
   b.insert(2, 7, 8, 9)
   println("第五步结果,在地址2处添加元素 7，8，9", b)
   println("And Then 遍历数组")
   for (i <- 0 to b.length - 1) {
    print(b(i) + " ")
   }
   println(" ")
   println("yield关键字生成新的数组")
   val result01 = for (elem <- b if  elem %2 ==0) yield 2 * elem
   for (cf <- result01){
    print(cf+" ")
   }

  println("数组B的和",b.sum,b.max,b.min)
  println("对数组进行排序")

  val bsorft=b.sorted    //正序
  for (lpp<- bsorft.reverse) //倒序
   println(lpp)
  }
 }

 4.hash映射与元祖操作

/**
  * Created with IntelliJ IDEA.
  * User: @别慌
  * Date: 2019-06-03
  * Time: 9:40
  * Description: 
  */
object flect {
  def main(args: Array[String]): Unit = {
    println("不可变映射")
    var scores = Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)
    println("可变映射")
    val scores01=scala.collection.mutable.Map("Alice"->10)
    //val score02=scala.collection.mutable.Map[String,Int]

    val result01=if(scores.contains("Alice")) scores("Alice") else 0
    val result02=scores.getOrElse("Alice",0)
    println("得到映射中的值",result01)
    println("第二种得到映射中的方法",result02)

    println("更新映射中的值，仅限变长映射")
    scores01("Alice")=100
    val result03=scores01.getOrElse("Alice",0)
    println("更新映射关系",result03)

    scores01("Brouther")=666
    val result04=scores01.getOrElse("Brouther",0)
    println("新增Map  Hash 映射方法一",result04)

    scores01+=("Bob"-> 23,"Tom"->12,"Jack"->13)
    val result05=scores01.getOrElse("Tom",0)
    println("新增Map hash 映射方法二",result05)

    scores01-=("Bob")
    val result06=scores01.getOrElse("Bob",0)
    println("移除映射方法二",result06)

    println("更新不可变映射的方法")
    val newScore=scores+("Bob" -> 10)//也可以增加映射关系
    val result07=newScore.getOrElse("Bob",0)
    println("改变不变映射的值",result07)

    scores=scores - "Bob"
    val result08=scores.getOrElse("Bob",0)
    println("减去不可变映射的值",result08)



    println("元祖操作(不同类型集合)")
    var tuple1=(1,3.14,"CFPL")
    var result11=tuple1._3
    println("取出元祖中的某值(从1开始)",result11)

    

  }
}

object simple {
  def main(args: Array[String]): Unit = {
    val  t="New York".partition(_.isUpper)
    println(t._1,t._2)
  }

元祖可以用于函数需要返回不止一个值的情况

拉链操作

object simple {
  def main(args: Array[String]): Unit = {
   //拉链操作
    val symbols=Array("<","-",">")
    val count=Array(2,10,2)
    val paris=symbols.zip((count))

    for ((s,n)<-paris) Console.print(s,n)  //输出映射值   

    val map=symbols.zip(count).toMap
    println(map)
  }
}

第5章，类