Scala学习历险记（第一天）

Scala学习笔记(一)

前言：由于最近要整大数据相关的东西，所以java开发的我很苦逼的来学习Scala了，为接下来的工作做知识储备，今天是2021年8月19号，是我接触scala语言的第一天，因此整理一下一天所得，可能比较简单基础，但作为第一次接触而言，算是不少收获了，之后也会在学习的过程中边整理边总结。下面这段话是百度上看到的Scala 是一门多范式（multi-paradigm）的编程语言，设计初衷是要集成面向对象编程和函数式编程的各种特性。Scala 运行在 Java 虚拟机上，并兼容现有的 Java 程序。Scala 源代码被编译成 Java 字节码，所以它可以运行于 JVM 之上，并可以调用现有的 Java 类库。可见scala语言和java的密不可分，接下来的学习也会结合它俩的特性来进行总结。

安装及配置Scala的环境

• 首先自己电脑上先拥有Java 8或者11的运行环境，具体可以参考https://www.runoob.com/java/java-environment-setup.html这一块不再赘述。
• 下载scala的安装包，在http://www.scala-lang.org/downloads上，这里我选择的是scala2版本，比较稳定，我下载的是scala-2.13.6.msi。
• 下载下来之后直接双击安装scala，注意选择安装目录时文件夹不要有空格，我第一次安装在了Program Files (x86)，结果一直提示我'scala' 不是内部或外部命令,也不是可运行的程序 或批处理文件。，更换目录后就好了。
• 配置环境变量，这里的配置和java及其相似，只不过要新建一个变量名为SCALA_HOME，变量值为scala安装路径的系统环境变量（java建的是JAVA_HOME）。然后在Path内添加上"%SCALA_HOME%\bin"即可
• 因为我是用的idea开发，因为首先我先去了IDEA中的file->setting->Plugins中搜索了Scala插件,下载下来安装后重启idea
• 然后新建项目和java的步骤如出一辙，只不过选择类型时不要选择java，要选择Scala，一路next，最后刚建出来时要等一会儿，因为它这里需要下载相关的依赖jar一类的，我大约等了十几分钟吧。等到加载完，就可以新建scala文件，进行愉快的开发了。

Scala的基本操作用法

scala和java很大的区别在于它每一行语句结束后，可以不用写;，但是在一行里想编写多个不同的语句，就需要用；分隔开,scala和java很多的关键字都是一样的，只不过是使用的语法上有所差异，接下来便通过我写的一些demo来感受scala的用法吧，就不再啰里啰嗦的讲学术了。我也是初学者，有不对的多多指教。

scala的常规使用

/**
 * scala基础
 * @author: zae
 * @date: 2021/8/19
 * @time: 11:09
 */
object FirstScala {
  /**
   *
   * @param args
   */
  def main(args: Array[String]) {
    // 第一个scala方法=输出 Hello World
    println("Hello, world!")

    // 定义变量： var关键字
    var name : String = "Zae";println("我的名字叫："+name);name = "aaa"
    var age : Int = 25; println("我的年龄是"+age);

    // 定义常量： val关键字，不能修改
    val address : String  = "北京";

    // 支持多个变量声明
    var num1,num2 = 100

    // 元祖
    var po:(Int,String) = (40,"four"); println(po)

    // for循环的使用
    println("=========for循环的使用=============")
    var i = 0;
    for (i <- 10 to 20){
      // 这里值的是从10循环到20
      println("for in to:"+i)
    }
    for(i <- 10 until 20){
      // 这里指的是从10循环到19，就是不包含最后的那个20了
      println("for in until"+i)
    }
    var j = 0;
    for(i <- 1 to 4;j <- 1 to 3){
      // 罗列出了所有i和j组合的可能性，类似于java中的双重for循环
      println("i="+i+"||j="+j);
    }
    // for循环结合集合使用
    val newList = List(2,3,4,5,6,7,8)
    for(i <- newList){
      println("集合for使用:"+i)
    }

    // for+if过滤
    for(i <- newList
        if i>=3;if i<=7){
      // 意思是遍历newList，并筛选出大于等于3和小于等于7的元素
      println("过滤后的结果为："+i)
    }

    // for使用yield，将过滤结果进行存储
    val result = for{i<-newList
        if i>=4;if i<=6}yield i
    // 输出返回值
    for(i <- result){
      println("收集的结果为"+i)
    }

    println("============while和do while的使用")
    var a = 0
    while (a<=5){
      a = a+1
      println("while的第"+a+"次循环")
    }
    do{
      println(" do while的第"+a+"次循环")
      a=a+1
    }while(a<=10)
  }

scala关于访问修饰符

/**
 * 关于访问修饰符
 * @author: zae
 * @date: 2021/8/19
 * @time: 11:41
 */
class TwoScala {
  // private访问修饰符,成员对象定义的类以及其内部类可见
  class InnerOne{
    private def f(){println("f")}
    class InnerMost{
      f() 
    }
  }

  // protected访问修饰符 只允许子类访问
  protected def testM(){println("protected")}
  class TwoScalaSmall extends TwoScala{
    testM()
  }

  // public都可以访问,默认情况就是public
  class InnerTwo{
    def testPub(){println("public")}
  }
  class  InnerThree{
    (new InnerTwo).testPub()
  }

}

Scala函数和方法

Scala函数这一块看起来要比java精彩一些，种类特别多，除了基础常见的定义函数加调用，还有10种比较特殊的，分别是函数传名调用(Call-by-Name)，函数 - 可变参数，默认参数值，内嵌函数，偏应用函数，指定函数参数名，递归函数，高阶函数，匿名函数，函数柯里化(Function Currying)。下面将通过我的demo演示各种函数的用法，有些解释直接写在注释中了。

import java.util.Date

/**
 * scala函数和方法
 * @author: zae
 * @date: 2021/8/19
 * @time: 14:44
 */
object SecondScala {

  def main(args: Array[String]){
    // 调用sum方法
    println("1+2="+sum(1,2))
    // 调用无参无返回方法
    outWord()
    // 传名调用使用
    dealTime(getNowTime())
    // 调用可变参数函数
    useParams("无尽","名刀","末世")
    // 调用含默认参数的方法-不传参
    println("不传参：a+b="+defaultParam())
    // 调用含默认参数的方法-传参
    println("传参：a+b="+defaultParam(100,200))
    // 调用内嵌函数
    println("内嵌函数结果为："+innerFun(4))
    // 调用偏应用函数
    appFunc();
    // 指定参数名进行调用
    nameFun(b = 10,a = 20)
    // 调用递归函数
    println("5的阶乘结果为:"+factFun(5))
    // 高阶函数
    println(apply(layout,10))
    // 调用匿名函数
    println("调用匿名函数的结果为:"+multFun(2,3))
    // 调用柯里化后的函数
    println("函数柯里化："+addFunKe(5)(6))
    // 调用闭包类的函数
    println("闭包："+multOneFun(10))

  }

  // 定义一个方法计算a+b
  def sum(a:Int,b:Int) : Int = {
    var num : Int = 0
    num = a+b
    return num
  }
  // 定义一个无返回值的方法
  def outWord(): Unit={
    println("我是一个无参无返回值的方法")
  }

  def getNowTime() = {
    println("获取时间，单位为纳秒")
    System.nanoTime()
  }

  // 定义传名方法
  def dealTime(t: =>Long) = {
    println("在dealTime方法内部")
    println("当前时间："+t)
    t
  }

  // 定义可变参数函数
  def useParams(args:String*) ={
    var i : Int = 0
    for(arg <- args){
      println("args["+i+"]="+arg)
      i = i+1
    }
  }

  // 定义含默认参数的函数
  def defaultParam(a:Int = 10,b:Int = 20):Int = {
    var num : Int = 0
    num = a+b
    num
  }

  // 内嵌函数
  def innerFun(a:Int):Int={
    def fact(i:Int,defaultNum:Int):Int = {
      if(i<=1)
        defaultNum
      else
        fact(i-1,i*defaultNum)
    }
    fact(a,1)
  }

  // 偏应用函数
  def appFunc() = {
    println("===开启偏应用函数的调用模式===")
    val date = new Date
    val logWithDate = log(date,_:String)
    logWithDate("message1")
    logWithDate("message2")
    logWithDate("message3")
  }
  def log(date:Date,message:String) = {
    println(date+"===="+message)
  }

  // 指定函数参数名
  def nameFun(a:Int,b:Int): Unit ={
    println("===开始指定参数名进行调用===")
    println("a的值："+a)
    println("b的值："+b)
  }

  // 递归函数，求a的阶乘
  def factFun(a:BigInt) : BigInt = {
    if (a==1)
     1
    else
    a*factFun(a-1)
  }

  // 高阶函数
  def apply(f:Int => String,v:Int) = f(v)
  def layout[A](x:A) = "["+x.toString+"]"

  // 匿名函数
  val multFun = (i:Int,j:Int) => i*j

  // 函数柯里化
  def addFunKe(a:Int)(b:Int) = a+b

  // 闭包：返回值依赖于声明在函数外部的一个或者多个变量
  var numOne = 10;
  val multOneFun = (a:Int)=>a*numOne
}

Scala常用数据结构一

这一部分不是包含所有的数据结构，只涉及到字符串，数组以及List集合的相关知识。后续的补充会在学习后进行总结。

import Array._
/**
 * Scala常用的数据结构一:字符串，数组，List集合
 * @author: zae
 * @date: 2021/8/19
 * @time: 16:21
 */
object ThreeScala {
  def main(args: Array[String]): Unit = {
    // 调用关于字符串的方法
    strBuf()
    // 调用数组方法
    arrFun()
    // 调用List列表方法
    listFun()
  }

  // 关于字符串的相关知识
  def strBuf() = {
    val buf = new StringBuilder;
    buf += 'a'
    buf ++= "bcdef"
    println("buf is : "+buf.toString())

    var str1 = "yyyyyy.com"
    println("yyyyyy.com的长度为"+str1.length())

    var str2 = "琴键的空间"
    println("str1和str2的连接结果为"+str1.concat(str2))

    var floatVar = 12.456
    var intVar = 10
    var stringVar = "ZAE"
    var fs = printf("浮点型变量为%f,整型变量为%d,字符串为%s",floatVar,intVar,stringVar)
    println(fs)
  }

  // 关于数组
  def arrFun() = {
    // 第一种声明数组的方式
    var z1 = new Array[String](3)
    z1(0) = "java";z1(1) = "python";z1(2) = "scala"

    // 第二种声明数组的方式
    var z2 = Array("java","python","scala")

    // 数组处理
    var myList = Array(1.9,3.8,5,6.1)
    var total = 0.0
    for(i <- 0 to myList.length-1){
      total += myList(i)
    }
    println("数组的总和为:"+total)

    var maxNum = myList(0)
    for(i <- 0 to myList.length-1){
      if(myList(i)>maxNum)
        maxNum = myList(i)
    }
    println("最大值为："+maxNum)

    // 多维数组
    val arrMany = Array.ofDim[Int](3,3)
    for(i<-0 to 2;j<-0 to 2){
      arrMany(i)(j) = i+j
    }
    // 打印二维阵列
    for(i<-0 to 2;j<-0 to 2){
      println("打印二维数组的结果为:arrMany["+i+"]["+j+"] = "+arrMany(i)(j))
    }

    // 合并数组
    var myList1 = Array(1,2,3,4)
    var myList2 = Array(5,6,7,8)
    var myList3 = concat(myList1,myList2)
    for(x <- myList3){
      print(x+"|")
    }

    // 区间数组
    var rangeList1 = range(10,20,2)// 从10-20，每隔2个算一个元素
    var rangeList2 = range(10,20)// 10-20之间所有的整数都是集合元素
    for(x <- rangeList1){
      print(" "+x)
    }
    for (elem <- rangeList2) {
      print(" "+elem)
    }
  }

  // 关于scala - List集合
  def listFun() = {
    // 字符串列表(以下为2种写法，后面同理)
    val site:List[String] = List("Java","python","Scala")
    var siteN = "Java"::("python"::("Scala"::Nil))

    //空列表
    val empty:List[Nothing] = List()
    val emptyN = Nil

    //二维列表
    var dim:List[List[Int]] =
      List(
        List(1,0,0),
        List(0,1,0),
        List(0,0,1)
      )
    var dimR =  (1::(0::(0::Nil))) ::
                (0::(1::(0::Nil))) ::
                (0::(0::(1::Nil))) :: Nil

    println("第一个语言是"+site.head)
    println("最后一个语言是"+site.tail)
    println("列表site是否为空:"+site.isEmpty)
    println("列表empty是否为空"+empty.isEmpty)

    // 连接列表的三种方式
    val word1:List[String] = List("Java","python","Scala")
    val word2:List[String] = List("C","C++","Html")
    // way1：使用:::运算符
    var wordResult = word1:::word2
    // way2：使用List.:::()方法
    wordResult = word1.:::(word2)
    // way3:使用concat方法
    wordResult = List.concat(word1,word2)
    println("word1和word2连接后的结果是:"+wordResult)

    //List.fill()创建一个指定重复数量的元素列表
    val fillList = List.fill(3)("scala")
    println("重复scala三次:"+fillList)

    //List.tabulate() 方法是通过给定的函数来创建列表
    val taListOne = List.tabulate(6)(n=>n*n)
    println("一维："+taListOne)
    val talListTwo = List.tabulate(3,4)(_*_)
    println("多维："+talListTwo)
  }
}

第一天就搭建了下环境和学习了下比较基础简单的用法，以后可能会愈来愈难，但是一定要坚持下去！