scala基础与进阶

方法与函数

两者的区分说明

Scala 有方法与函数，二者在语义上的区别很小，在绝大多数情况下，两者是视为对等的。
Scala 方法是类的一部分，而函数是一个对象可以赋值给一个变量，即在类中定义的函数即是方法。
Scala 中的方法跟 Java 的类似，方法是组成类的一部分。
Scala 中的函数则是一个完整的对象，Scala 中的函数其实就是继承了 Trait 的类的对象。
Scala 中使用 val 语句可以定义函数，def 语句定义方法。

方法定义

定义格式

def functionName ([参数列表]) : [return type] = {
    function body
    return [expr]
}

相关说明

如果不写等于号和方法主体，则方法会被隐式声明为"抽象方法"，包含它的类型于是也是一个抽象类型。
return type 可以是任意合法的 Scala 数据类型，如果函数没有返回值，可以返回为 Unit，这个类似于 Java的 void
参数列表中的参数可以使用逗号分隔。

方法调用

调用说明

当不需要实例化对象时，functionName(参数列表)即可
当需要实实例化对象时，为 instance.functionName(参数列表)即可

闭包

闭包概念

闭包是个函数。
函数计算的过程，依赖于声明在函数外部的一个或多个变量。
 

object TestCloseFunction {
    var factor = 1000
    def salaryMoney(i: Int): Int = {
    return i * factor
    }
    def main(args: Array[String]) {
        println("月薪 salaryMoney(8) value = " + salaryMoney(8))
        println("月薪 salaryMoney(10) value = " + salaryMoney(10))
        TestCloseFunction.factor = 10000;
        println("年薪 salaryMoney(8) value = " + salaryMoney(8))
        println("年薪 salaryMoney(10) value = " + salaryMoney(10))
    }
}

字符串

概念介绍

在 Scala 中，字符串的类型实际上是 Java String，它本身没有String 类。
完全与 java.lang.String对等

不可变字符串创建

object TestString {
    var message = "过年好!";
    var messageV2: String = "过年好!";
    def main(args: Array[String]): Unit = {
        println(message);
        println(messageV2);
    }
}

可变字符串创建(StringBuilder)

object TestStringBuilder {
    def main(args: Array[String]) {
        val stringBuilder = new StringBuilder;
        stringBuilder += '1'
        stringBuilder ++= "234"
        stringBuilder.append("567")
        stringBuilder.append('8')
        println("stringBuilder is : " + stringBuilder.toString);
    }
}

求字符串长度 length方法

def main(args: Array[String]) {
    var str="12345678";
    println("str length()="+str.length());
}

字符串连接 concat或是+符号

def main(args: Array[String]) {
    var str = "12345678";
    var str2 = "9";
    println("str.concat(str2)=" + str.concat(str2));
    println("str.concat(str2)=" + str + str2);
}

字符串格式化 printf

def main(args: Array[String]) {
    var name = "天亮教育";
    var location = "石家庄";
    var work = "大数据技能培训";
    var age=21;
    printf("我是%s,我在%s,我做%s,我今年%d 岁了",name,location,work,age);
}

数组

概念说明

用来存储固定大小的同类型元素
元素是通过索引来访问的，第一个元素索引为 0，最后一个元素的索引为元素总数减 1

数组定义

静态数组

def main(args: Array[String]): Unit = {
    var programLanguageArray = Array("java", "python", "c++", "c", "php")
    for (program <- programLanguageArray) {
        println(program);
    }
}

动态数组

def main(args: Array[String]): Unit = {
    var programLanguageArray = new Array[String](5)
    // var programLanguageArray:Array[String] = new Array[String](5)
    programLanguageArray(0) = "java";
    programLanguageArray(1) = "python";
    programLanguageArray(2) = "c++";
    programLanguageArray(3) = "c";
    programLanguageArray(4) = "php";
    for (program <- programLanguageArray) {
        println(program);
    }
}

数组遍历操作

def main(args: Array[String]): Unit = {
    var programLanguageArray = new Array[String](5)
    programLanguageArray(0) = "java";
    programLanguageArray(1) = "python";
    programLanguageArray(2) = "c++";
    programLanguageArray(3) = "c";
    programLanguageArray(4) = "php";
    println("加强 for 循环遍历");
    for (program <- programLanguageArray) {
        println(program);
    }
    println("数组下标循环遍历");
    for (i <- 0 to (programLanguageArray.length - 1)) {
        println(programLanguageArray(i))
    }
}

多维数组

概念

多维数组(>=2)即为数组的数组，与 Java中概念等同
数组中的元素即可以是实体的值，也可以是一个数组，且可以嵌套

多数数组定义与应用

import Array.ofDim;
    object TestMultiArray{
    def main(args: Array[String]): Unit = {
        var myMatrix = ofDim[Int](4, 4)
        // 创建二维方阵 
        for (i <- 0 to myMatrix.length - 1) {
            for (j <- 0 to myMatrix.length - 1) {
                myMatrix(i)(j) = (i + 1) * (j + 1);
            }
        }
        // 输出二维方阵
        for (i <- 0 to myMatrix.length - 1) {
            for (j <- 0 to myMatrix.length - 1) {
                print(" " + myMatrix(i)(j));
            }
            println();
        }
    }
}

数组合并

import Array.concat;
    object TestArray {
        def main(args: Array[String]): Unit = {
            var numberList1 = Array(1, 2, 3, 4)
            var numberList2 = Array(5, 6, 7, 8)
            var mergeList = concat(numberList1, numberList2)
            // 输出所有数组元素
            for (x <- mergeList) {
                println(x)
            }
        }
    }

创建区间数组

区间数组说明

range() 方法来生成一个区间范围内的数组
range() 方法最后一个参数为步长，默认为 1
是半包区间，包含起始值，不包括结束值，即start<=x<end

import Array.range;
    object TestArrayRange {
        def main(args: Array[String]): Unit = {
            var numberList1 = range(1, 5, 2)
            var numberList2 = range(1, 5)
            println("手动设置步长为 2")
            // 输出所有数组元素-numberList1
            for (x <- numberList1) {
                println(x)
            }
            println("采用默认步长值，即为 1")
            // 输出所有数组元素-numberList2
            for (x <- numberList2) {
                println(x)
            }
        }
    }

函数传名调用

概念说明

传值调用：先计算参数表达式的值，再应用到函数内部，把=>去掉即可，即按原始的方式
传名调用：将未计算的参数表达式直接应用到函数内部，用=>来设置传名调用
传值

object TestCallByValue {
    def main(args: Array[String]) {
        delayedCalculator(transmitMe());
    }
    def transmitMe(): String = {
        println("我在 transmitMe方法中!")
        return "transmitMe返回值";
    } 
    def delayedCalculator(t: String): Unit = {
        println("在 delayedCalculator方法--开始")
        println("正式调用传过来的函数： " + t)
        println("在 delayedCalculator方法--结束")
    }
}

传名

object TestCallByName {
    def main(args: Array[String]) {
        delayedCalculator(transmitMe());
    }
    def transmitMe(): String = {
        println("我在 transmitMe方法中!")
        return "transmitMe返回值";
    }
    def delayedCalculator(t: => String): Unit = {
        println("在 delayedCalculator方法--开始")
        println("正式调用传过来的函数： " + t)
        println("在 delayedCalculator方法--结束")
    }
}

指定函数参数名调用

object TestCallByParaName {
    def main(args: Array[String]) {
        printBabyNames(second = "张二", first = "张一");
    }
    def printBabyNames(first: String, second: String): Unit= {
        println("第一个孩子叫=" + first);
        println("第二个孩子叫=" + second);
    }
}

可变(不定长)参数的函数

object TestNonFixParas {
    def main(args: Array[String]) {
        printAllParasValue("one", "two", "three", "four");
    }
    def printAllParasValue(paras: String*): Unit = {
        for (temp <- paras) {
            println(temp);
        }
    } 
}

默认参数值函数

object TestDefaultParaFunction {
    def main(args: Array[String]) {
        println("完全使用默认值的返回值 : " + salaryMoney());
        println("部分使用默认值的返回值 : " + salaryMoney(10));
        println("部分使用默认值的返回值 : " + salaryMoney(10,10000));
    }
    def salaryMoney(a: Int = 5, unit: Int = 1000): Int = {
        return a * unit
    }
}

递归函数

object TestRecusive {
    def main(args: Array[String]) {
        var n=4
        println(n+"的阶乘为="+myFactorial(n))
    }
    def myFactorial(n: Int): Int = {
        if (n <= 1)
            return 1
        else
            return n * myFactorial(n - 1)
    }
}

高阶函数

概念说明

第一种：将一个函数当做另外一个函数的参数，即参数为函数的函数
第二种：返回值是函数的函数，即高阶函数可以产生函数参数为函数的函数
参数为函数的函数

object TestHighFunctionByTransmitFunctionPara {
    def main(args: Array[String]) {
        delayedCalculator(transmitMe());
    }
    def transmitMe(): String = {
        println("我在 transmitMe方法中!")
        return "transmitMe返回值";
    } 
    def delayedCalculator(t: => String): Unit = {
        println("在 delayedCalculator方法--开始")
        println("正式调用传过来的函数： " + t)
        println("在 delayedCalculator方法--结束")
    }
}

返回值是函数的函数

object TestHighFunctionByRetFunction {
    def main(args: Array[String]) {
        var mySalaryFun=multiplyBy(1000);
        println(mySalaryFun(10));
    }
    def multiplyBy(salaryUnit:Int)=(x:Int)=>salaryUnit*x
}

内嵌函数

概念介绍

函数内定义函数，定义在函数内的函数称之为局部函数，亦称内嵌函数
 

object TestEmbedFunction {
    def main(args: Array[String]) {
        var msg="HelloWorld";
        printMessage(msg);
    }
    def printMessage(msg: String): Unit = {
        def printMessageInner(msg: String): Unit = {
            println(msg);
        }
        printMessageInner(msg);
    }
}

匿名函数

概念介绍

没有函数名称的函数
使代码更简洁，用=>来表示，左侧是参数列表，右侧是函数体

匿名用法（使值自增+1的函数实现）
 

//函数定义：
var inc = (x:Int) => x+1
//函数使用：
var x = inc(8)+1

正常写法（使值自增+1的函数实现）

//正常定义：
def incFunction(x: Int): Int = {
    return x + 1;
}
//函数使用：
var x=incFunction(8)+1

偏应用函数

概念说明

不需要提供函数需要的所有参数，只需要提供部分，或不提供所需参数
实现方法：绑定函数的一部分参数，非绑定部分用"_"代替，从而形成偏应用函数去使用

传统方法实现（向某人问好)

import java.util.Date
    object TestPartialParasFunction {
        def main(args: Array[String]) {
            val name="张三"
            sayHello(name, "上午好")
            Thread.sleep(1000)
            sayHello(name, "中午好")
            Thread.sleep(1000)
            sayHello(name, "晚上好")
        }
        def sayHello(name: String, message: String)= {
            println(name + "----" + message)
        }
    }

偏应用函数实现（向某人问好)

def main(args: Array[String]) {
    val name="张三"
    val partialSay=sayHello(name,_:String);
    partialSay("上午好")
    Thread.sleep(1000)
    partialSay("中午好")
    Thread.sleep(1000)
    partialSay("晚上好")
}
def sayHello(name: String, message: String) = {
    println(name + "----" + message)
}

函数柯里化

概念说明

将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数。
提高了使用方法的灵活性

传统实现 add方法定义

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

传统实现 add方法使用

def main(args: Array[String]) {
    println(add(3,4));
}
def add(x: Int, y: Int) = x + y;

柯里化实现 add方法定义

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

柯里化实现 add方法使用

object TestCurryingFunction {
    def main(args: Array[String]) {
        //对应柯里化形式 1的使用
        var curryingAdd1 = add1(3)
        //对应柯里化形式 2的使用
        var curryingAdd2 = add2(3)(_)
        println(curryingAdd1(4));
        println(curryingAdd1(4));
    }
    //柯里化形式 1
    def add1(x: Int) = (y: Int) => x + y;
    //柯里化形式 2
    def add2(x: Int)(y: Int) = x + y;
}

集合

list

    //List
    val list1:List[String] = List("tom","jack")
    list1.foreach(x=>println(x))

用Nil和::来构建列表

    //使用Nil构建链表
    val list2 = "antg"::("jack"::("tom"::Nil))
    list2.foreach(x=>println(x))

Set
Map
元组
Option
Iterator