scala vs java有意思的区别

￡神魔★判官ぃ 2022-04-03 03:26 151阅读 0赞

## 标题A、导入通配符 ##

\*在Scala中是合法的方法名，所以导入包时要使用\_代替。

//Java
    import java.util.*;
     
    //Scala
    import java.util._

## 类成员默认值 ##

// java 
    //Java中类成员可以不赋初始值，编译器会自动帮你设置一个合适的初始值：
    class Foo{
         //String类型的默认值为null
         String s;
    }
    
    //scala
    //而在Scala中必须要显式指定，如果你比较懒，可以用_让编译器自动帮你设置初始值：
    class Foo{
        //String类型的默认值为null
        var s: String = _
    }

## 可变参数 ##

// java
    public static void printArgs(String ... args){
        for(Object elem: args){
            System.out.println(elem + " ");
        }
    }
     //传入两个参数
    printArgs("a", "b");
    //也可以传入一个数组
    printArgs(new String[]{"a", "b"});
    //在Java中可以直接将数组传给printArgs方法，但是在Scala中，你必须要明确的告诉编译
    //器，你是想将集合作为一个独立的参数传进去，还是想将集合的元素传进去。如果是后者则
    //要借助下划线：
    printArgs(List("a", "b"): _*)
    
    
    //scala  可变参数定义
    def add(values:Int*):Int = {
    	var result = 0
    	for (value <- values) {
    		result = result + value
    	} 
    	result
    }

## 类型通配符 ##

//Java的泛型系统有一个通配符类型，例如List<?>，
    //任意的List<T>类型都是List<?>的子类型，
    //如果我们想编写一个可以打印所有List类型元素的方法，可以如下声明：
    public static void printList(List<?> list){
        for(Object elem: list){
            System.out.println(elem + " ");
        }
    }
    
    
    对应的scala 版本为：
    def printList(list: List[_]): Unit ={
       list.foreach(elem => println(elem + " "))
    }

## 模式匹配 ##

// 默认匹配
    str match{
        case "1" => println("match 1")
        case _   => println("match default")
    }
    
    //匹配集合元素
    //匹配以0开头，长度为三的列表
    expr match {
      case List(0, _, _) => println("found it")
      case _ =>
    }
     
    //匹配以0开头，长度任意的列表
    expr match {
      case List(0, _*) => println("found it")
      case _ =>
    }
     
    //匹配元组元素
    expr match {
      // 以0 开头，2个元素的元组
      case (0, _) => println("found it")
      case _ =>
    }
     
    //将首元素赋值给head变量
    val List(head, _*) = List("a")

## scala 特有语法 ##

// 简写字面常量
    val f1 = (_: Int) + (_: Int)
    //等价于
    val f2 = (x: Int, y: Int) => x + y
     
    list.foreach(println(_))
    //等价于
    list.foreach(e => println(e))
     
    list.filter(_ > 0)
    //等价于
    list.filter(x => x > 0)
    
    
    // 访问tupule 元素
    val t = (1, 2, 3)
    println(t._1, t._2, t._3)
    
    
    // 定义部分函数
    def sum(a: Int, b: Int, c: Int) = a + b + c
    val b = sum(1, _: Int, 3)
    b: Int => Int = <function1>
    b(2) //6
    
    
    
    //Scala中方法和函数是两个不同的概念，方法无法作为参数进行传递，
    //也无法赋值给变量，但是函数是可以的。在Scala中，
    //利用下划线可以将方法转换成函数：
    //将println方法转换成函数，并赋值给p
    val p = println _  
    //p: (Any) => Unit
    
    
    def m1 = 100  // 没有参数的方法
    def m1() = 100  // 参数列表为空的方法