scala基础操作笔记

object funcextends App {

def hi(name:String):String = {

s"my name is ${name}"

  }

def add(x: Int, y: Int) = x + y

println(add(1,2))

println(hi("哈哈哈哈"));

val l =List("alice","bob","cathy");

//遍历元素打印

  for (

s <-l //generator

  )println(s)

//如果s长度大于3

  for {

s <-l

    if (s.length >3)//filter

  }println(s)

val result_for =for {

s <-l;

s1 = s.toUpperCase()

if (s1 !="")

}yield (s1)//导出

  println(result_for)

try {

Integer.parseInt("dog")

}catch {

case _ =>0

  }finally {

println("err")

}

val code =1;

val result_match =code match {

case 1 =>"one"

    case _ =>"otrhers"

  }

println(result_match)

//call by val

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

//call by name

  def test2(x: => Int, y: => Int): Int = x * x

println(test1(3 +4,3));

println(test2(3 +4,3));

def bar(x: Int, y: => Int): Int =1

  def loop(): Int =loop()//递归

//由于y没有被用到 所以loop没有执行 所以正常输出

  println(bar(1,loop))

//由于loop为死循环 所以导致无法求值

//println(bar(loop, 1))

  def operate(f: (Int, Int) => Int) = {

f(4,4)

}

def greeting(age: Int) = (name:String) => {

s"Hello $name,your age is $age"

  }

println(greeting(23)("Flygar"));

var sum = (x: Int, y: Int) => x + y;//add是一个具有函数类型的变量

  println(sum(1,2))//返回值：Int=3

//柯里化

  def curriedAdd(a: Int)(b: Int) = a + b

curriedAdd(2)(2)

//为第二个参数传值 复用curriedAdd

  val addOne =curriedAdd(1) _

addOne(2)

//递归函数

  def factorial(n: Int): Int = {

if (n <=0)1

    else n *factorial(n -1)

}

//尾递归 当编译器检测到一个函数调用是尾递归的时候 他就覆盖当前的活动记录而不是在栈中去创建一个新的

//定义尾递归

  @annotation.tailrec

  def factorials(n: Int, m: Int): Int =

if (n <=0) m

else factorials(n -1, m * n)

println(factorials(5,1))

//计算fx的和 x为a-b之间的整数

  def sumfunc(f: Int => Int)(a: Int)(b: Int): Int = {

@annotation.tailrec

    def loop(n: Int, acc: Int): Int = {

if (n > b) {

println(s"n=${n},acc=${acc}")

acc

}else {

println(s"n=${n},acc=${acc}")

loop(n +1, acc + f(n))

}

}

loop(a,0)

}

sumfunc(x => x)(1)(5)

sumfunc(x => x * x)(1)(5)

sumfunc(x => x * x * x)(1)(5)

val sumSquare =sumfunc(x => x * x) _

sumSquare(1)(5)

val a =List(1,2,3,4)

val b =0 ::a

  val c ="x" ::"y" ::"z" ::Nil

  val e =a :::b :::c

  println(e)

//返回第一个元素

  println(e.head)

//返回剩下的元素

  println(e.tail)

//判断是否为空

  println(e.isEmpty)

def walkthru(l:List[Any]):String = {

if (l.isEmpty)" "

    else l.head.toString +" " +walkthru(l.tail)

}

println(walkthru(e:List[Any]))

//x为遍历数组中的元素输出奇数 并且加一

  println(a.filter(_ %2 ==1).map(_ +1))

//返回数字

  println("dsadsa1121zz".toList.filter(x => Character.isDigit(x)))

//当takewhile 没取到B之前循环读取

  println("dsadsa1121zz".toList.takeWhile(_ !='B'))

//映射所有元素转为大写

  println(c.map(x => x.toUpperCase()))

println(c.map(_.toUpperCase()))

//二维

  val q =List(a,List(5,6))

//去除偶数 flatMap返回单维

  println(q.flatMap(_.filter(_ %2 ==0)))

//求和 reduce值类型与list类型一致

  println(a.reduce(_ + _))

//foldLeft ；初始值类型就是返回值类型

  println(a.foldLeft(0)(_ + _))

//Range 大于等于1 小于等于10

  println((1 to10 by2).toList)

//Range 大于等于1 小于10

  println((1 until10 by2).toList)

//stream

  val stream = (1 to1000).toStream

println(stream.head)

println(stream.tail)

val t = (1,"Alice","age","12")

println(t._1)

/*元素长度，元素求和，元素平方和 */

  def sumSq(in:List[Int]): (Int, Int, Int) =

in.foldLeft((0,0,0))((t, v) => (t._1 +1, t._2 + v, t._3 + v * v))

println(sumSq(List(1,2,3)))

//map取值

  val p =Map(1 ->"David",9 ->"Elwood")

println(p(1))

/*判断values是否存在*/

  p.contains(1)

/*取出key*/

  p.keys

/*取出values*/

  p.values

/*增加一个value用“+”*/

  p + (8 ->"Bon")

/*减少一个value用“-”*/

  p -1

  /*增加多个value用“++”*/

  p ++List(2 ->"Jane",5 ->"jack")

/*减少多个value用“--”*/

  p --List(1,9,2)

/*增加和减少多个value可以同时用“++”“--”*/

  p ++List(2 ->"Jane",5 ->"jack") --List(9,1)

//快速排序

/*输入是一个List，输出是一个排好序Int类型的List */

/*如果List只有一个元素或为空，排序就是本身*/

  def qSort(a:List[Int]):List [Int] =if (a.length <2)  aelse qSort(a.filter(_ < a.head)) ++ a.filter( _ ==a.head)++qSort(a.filter(_>a.head))

print(qSort(List(4,5,2,6,1,3)))

}