Scala 学习笔记

object A
{    
    //统一java数值型和引用型在scala是 Any
    var echo = (arg:Any)=> println(arg);
    //匿名方法赋值给变量的方法实际上产生了一个FunctionN对象，并产生了一个这个对象的apply()方法，方法的参数个数就是匿名函数的参数个数
    val x = (arg:String)=>arg;
    //val a = Array.apply(1,2,3);
    val j = List(a:_*);
    //val k = Array.apply(a:_*);//no `: _*' annotation allowed here (such annotations are only allowed in arguments to *-parameters)
    val a = 1 to 100;
    //函数声明 在输入中指定类型，输出类型在函数定义中
    val even = (x:Int)=> x % 2 == 0;
    //函数声明时将输入输出类型指定，然后后面直接定义函数体
    val odd:Int=>Boolean = x => x % 2 == 1;
    val list =(a:Range,m:Int=>Boolean) => a.filter(m);
    val aa = list(a,even).mkString(",");
    val hasChar = (s:String,c:Char)=>s.exists((p:Char)=>p==c);
    def fab(x:Int,y:List[Int]):List[Int]=
    {
        if(x==0)
            return y.reverse;
        val a::b::rest = y;
        fab(x-1,a+b::y);    
    
    }
    val u = fab(15,List(1,1));

    val f = (p:Int)=> print(p+"\t");
    //变长参数
    def sum(nums:Int*):Int=
    {
        var x =0;
        nums.foreach(x+=_);
        return x;
    }
    //伴生对象的apply方法可以直接用类名调用 H(a,b,c);
    def apply(nums:Int*):Int=
    {
        var x =0;
        nums.foreach(x+=_);
        return x;
    }
    def main(args:Array[String]):Unit=
    {
        println(sum(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23));
        val j = Array(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23);
        //将数组传入变长参数函数中的方法
        println(sum(j:_*));
        print(A(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23));
         // val echo = (args:String*) => args.foreach(println);//error: ')' expected but identifier found.
    //  def echo(arg:String) = println(arg); ok
     // val x = echo _; ok
    //  var x = (arg:String)=>println(arg); ok
     var s = println(_:String);
     //val exex = (a:String=>(),b:String)=>a(b); String=>() is error
     val exex = (a:String=>Unit,b:String)=>a(b);
     exex(s,"hello");
     /*
        val f = (p:Int)=>
        {
            val x = p+1;
            x; //这种写法只能不要 return 否则 执行 f 返回 ()
        }
        */
        def f(p:Int):Int =
        {
            val x = p+1;
            return x;//这种写法可以要 return 也可以不要 return
        }
        print(f(4));
    }
}

object AB
{
    type moudle = () => Unit;

    def x(p:moudle):Unit=
    {
        p();
        println();
        p();
    }
    def main(args:Array[String]):Unit = 
    {
            x(()=>print("hello"));
    }
}

object D
{
    def sum(x:Int,y:Int,z:Int):Int = x+y+z;
    def main(args:Array[String]):Unit = 
    {
        val t = sum _; // 将def定义的函数变成变量传递
        val s = t(1,_:Int,_:Int);
        print(s(3,4));
    }
}

object E
{
    //这样效率高一些，因为反编译后发现直接转化为循环
    def fac(x:Int,y:Int):Int =
    {
        if(y==1)
            return x;
        return fac(x*y,y-1)
    }
    def fac2(x:Int):Int =
    {
        if(x==1)
            return 1;
        return x*fac2(x-1);
    }
    def main(args:Array[String]):Unit = 
    {
        println(fac(1,10));    
        println(fac2(10));
    }
}

object W //几种定义函数的方法
{
    def main(args:Array[String]):Unit = 
    {
            val add:(Int,Int)=>Int = (x,y) => x+y;
            //val 常量名称:(输出参数类型列表)=>返回类型 = (输入参数列表) => 函数定义

            val add2 = (x:Int,y:Int) => x + y;
            //val 常量名称 = (输入参数和类型列表) => 函数定义;

            def add3(x:Int,y:Int):Int = x + y;
            // def 函数名称(输入参数和类型列表):返回类型 = 函数定义;

            // val x:Int=>Int = x => x+1; //直接写 x+1 是不对的
            val x:Int=>Int = { case x => x+1;}
    }
}

object X
{
    def main(args:Array[String]):Unit = 
    {
        //这个地方如果没有 lazy 关键字 repeat 无法实现递归定义，或者放到函数外面变成一个 object 属性变量，也不会立即求值
        lazy val repeat : Stream[Int] = 12 #:: repeat; //Stream 是懒加载的列表，换成 List 将出现死循环
        val z = repeat take (3);
        z.foreach(println);
    }
}

object Y
{
    def main(args:Array[String]):Unit = 
    {
        // 这个地方如果没有 lazy 关键字 的话定义常量的同时就会求值，所以里面的递归定义将导致对一个未定义完的变量求值
        // 或者将这个变量定义到 main 函数外面 变成一个 object 属性变量，也不会立即求值
        // 还有就是这种递归函数用 def 直接定义函数会更简单明确
        lazy val fact:Int=>Int= 
        {
            case 0=>1;
            case n => n*fact(n-1); //或者没有递归的时候也可以不要 lazy 关键字
        }
        print(fact(10));
    }
}

object V
{
    import scala.actors.Actor;
    import scala.actors.Actor._;

    def main(args:Array[String]):Unit = 
    {
            //两个 actor 对话
            val a = actor
            {
                    react
                    {
                        case (msg:String,sender:Actor) => println(msg);sender ! msg + " too";
                    }
            }

            val b = actor
            {
                react
                {
                    //给另外一个 actor 发送消息 同时发送自己的引用, self.act 实现自身的再次调用
                    case "start" => a ! ("hello",self);self.act(); 
                    case msg:String => println(msg);
                }
            }
            b ! "start";
    }
}

object U
{
    def main(args:Array[String]):Unit = 
    {
        // 隐式类型转换 自动将 String 转换为一个包含了你想的给String新加了一个方法的匿名类
        implicit def arrayOpt(a: String) = new 
        {  
                def -> (b:String) = (a,b);
        } 

        // 这里如果将左括号写到下一行 scala 会理解为声明了一个空数组，然后又声明了一个元祖
        val z = Array(
            "name"->"wengmj",
            "age"->"33"
        );
        for(xx <- z) println(xx);
    }
}

object T
{
    def sum(x:List[Int]):Int= x match
    {
        case List()=>0;
        case a::b =>a+sum(b);
    }
    
    //这里可以写成 x => x match 或_ match 或完全省略，但是直接写 x match 是错误的
    // 变量直接声明称 函数类型 类型为：x => y 的定义方法 如果又用到了 case 语法，case 前的 变量可以理解为参数声明
    val s:List[Int]=>Int = 
    {
        case List()=>0;
        case a::b =>a+sum(b);
    }

    val t=(x:List[Int])=>x match
    {
        case List()=>0;
        case a::b =>a+sum(b);
    }

    def main(args:Array[String]):Unit = 
    {
        // _@_* 匹配数组的多个元素
            val Array(a,_,b,_@_*) = Array(1,2,8,4,5);
            println(b);
            println(s(List(1,2,3)));
    }
}

object Q
{
    def expr(x:Any) = x match
    {
        case 5 => "ok";
        case true => "truth";
        case s : String => "string";
        case _ => "other";
    }
    val exp:Any=>String =
    {
        case 5 => "ok";
        case true => "truth";
        case s : String => "string";
        case _ => "other";
    }
    def main(args:Array[String]):Unit = 
    {
        println(expr(4));    
    }
}

object N
{
    def main(args:Array[String]):Unit = 
    {
            //这个地方是个模式匹配
            val State(res) = State("abcdefg") >> (_ * 3) >> (_ drop 3)  
            println(res);
    }
    case class State(var s: String) 
    {  
            type Func = String => String  
            def >> (f: Func) = 
            {  
                    s = f(s)
                    this
            }  
    }     
}

object J
{
    //用折叠操作实现列表的反转
    def reverse(x:List[Int]):List[Int] =
    {
        val f:(List[Int],Int)=>List[Int] = (x,y)=>y::x;
        val l = List[Int]();
        (l/:x)(f);
    }
    def main(args:Array[String]):Unit = 
    {
        val x = List(1,2,3,4,5,6,7,8,9);
        print(reverse(x));
    }
}

//插入排序
object I
{
    val sum:Int=>Int =
    {
        case 0 => 0;
        case x => x+sum(x-1);
    }

    val isort:List[Int]=>List[Int] = 
    {
        case Nil => Nil;
        case x::xs1 => insert(x,isort(xs1));
    }

    val insert:(Int,List[Int])=>List[Int] = //这里省略 xx match 的意思是整个输入参数的match
    {
        case (x,Nil) => List(x);
        case (x,y::ys) => if(x<=y) x::y::ys; else y::insert(x,ys);
    }

    def main(args:Array[String]):Unit = 
    {
            val x = isort(List(1,4,6,2,3,7,9,5,8));
            print(x.mkString(","));
    }
}

object H
{
    def main(args:Array[String]):Unit = 
    {
      //简明易懂，柯里化函数定义最好用 def x()() 方法定义
        def loop1(r: Range)(o: Int=> Unit) {r.foreach(o);} 
        //不容易理解
        val loop2 = (r:Range) => (o:Int=>Unit) => r.foreach(o);
    }
}

case class BinOp(x:Double,op:String,y:Double);
object G
{
    def eval(exp:BinOp):Double = exp match
    {
        case BinOp(x,"+",y) => x+y;
        case BinOp(x,"-",y) => x-y;
        case BinOp(x,"*",y) => x*y;
        case BinOp(x,"/",y) => x/y;
    }
    def main(args:Array[String]):Unit = 
    {
        print(eval(BinOp(3,"/",5)));
    }
}