Scala基础篇【上】

最新推荐文章于 2022-12-02 19:24:55 发布

江湖侠客

最新推荐文章于 2022-12-02 19:24:55 发布

阅读量180

点赞数

分类专栏： Scala语言文章标签： scala

本文链接：https://blog.csdn.net/weixin_39868387/article/details/118821377

版权

Scala语言专栏收录该内容

12 篇文章 0 订阅

订阅专栏

1、Scala的HelloWorld程序

代码实现：

package org.apache.scala


/**
 * 时间： 2021/7/16 8:40
 * 描述： Scala的HelloWorld程序
 *
 * 核心要点：
 *
 * 1、类名和文件名
 * 2、main方法的定义(注意和java的main方法对比理解)
 * 3、分号(可有可无)
 * 4、编译和执行(scalac和scala)
 * 5、类的声明(object和class)
 */
object Demo000_HelloWorld {

  var name: String = "zhangsan"

  def main(args: Array[String]): Unit = {
    println("hello world")
    println(name)
  }
}

控制台打印输出

2、变量使用

val 相当于Java中的final关键字修饰的变量，一旦赋值便不能更改，当未指定类型时，Scala会根据实际类型进行类型推断,上面前三种方式结果相同。
lazy关键字修饰的变量，定义时不赋值，真正使用时才赋值
var关键字修饰的变量，可以被重新赋值

e也可以是大写E,0.1214e1 = 0.1314*10

e也可以是大写E,0.1214e2 = 0.1314*10*10

代码实现

package org.apache.scala.day01

object Demo001_Variable {

  def main(args: Array[String]) {

    //使用val定义的变量值是不可变的，相当于java里用final修饰的变量
    val i = 1
    //使用var定义的变量是可变得，在Scala中鼓励使用val
    val s = "hello"
    //Scala编译器会自动推断变量的类型，必要的时候可以指定类型
    //变量名在前，类型在后
    val str: String = "NXNX奈学教育"
    println(i, s, str)


    // 定义变量
    val hello1 = "Hello Scala"
    val hello2: String = "Hello Scala"
    val hello3: java.lang.String = "Hello Scala"
    lazy val hello4 = "Hello Scala"

    // 使用val修饰的变量是不可更改变量。相当于java中的final关键字修饰的变量
    // 这个赋值操作是不被允许的： hello5 = "hello spark"
    val hello5 = "Hello Scala"


    // 使用var修饰的变量可以修改为同类型的其他值， 但是使用val修饰的变量一定不能修改
    var hello6 = "hello"
    // 这个赋值操作是错误的： hello6 = 4
    hello6 = "hi" // 这个操作是允许的

    val x1 = 0x29 //十六进制定义整数
    val x2 = 41 //十进制定义整数
    val x3 = 51 //八进制数定义
    println(x1, x2)

    val doubleNumber = 3.14159 //Double类型定义，直接输入浮点数，编译器会将其自动推断为Double类型
    val floatNumber1 = 3.14159F //定义Float类型浮点数，需要在浮点数后面加F或f
    val floatNumber2 = 0.1314e-1 // 科学计数法
    println(doubleNumber, floatNumber1, floatNumber2)

    // 字符定义，用单引号(')将字符包裹
    var letter = 'A'
    // 如果需要原样输出字符串中的内容，则用三个双引号"""将字符串包裹起来
    val hello = """Hello  \n \t \b \\ Scala"""
    // 定义布尔变量
    var bool = true
    println(letter, hello, bool)
  }
}

打印输出

3、数据类型

Any是所有类的父类，包括值类型AnyVal，和引用类型AnyRef
AnyVal是所有值类型的父类，包括Int，Double，Boolean，Unit等等
AnyRef是所有引用类型的父类，包括Null
Null是所有引用类型的子类
Nothing是所有类的子类
Unit类型只有一个实例，是()，相当于java中的void，没有任何的实质意义
Null也只有一个实例，是null，相当于java中的null，能赋值给任何引用类型变量，不能赋值给值类型变量

代码实现：

package org.apache.scala.day01

/**
 * 描述： 数据类型
 */
object Demo002_Type {

  def main(args: Array[String]): Unit = {

    val var_int = 1
    val var_double = 3.33
    val var_float = 2.4F
    val var_char = 'A'
    val var_bool = true
    println(var_int, var_double, var_float, var_char, var_bool)

    val var_16 = 0x29
    val var_string = "aa"
    val var_string1 = "\"huangbo\""
    val var_string2 = """hello\thello\na\t\\"""

    println(var_16)
    println(var_string)
    println(var_string1)
    println(var_string2)

  }
}

打印输出：

4、操作运算符

算术操作：+ - * / %
关系运算：> >= < <= == !=
逻辑运算：&& || !
位运算： & | ^ >> << >>>
对象比较：1==1 1==1.0 "huangbo" == "huangbo"

代码实现：

package org.apache.scala.day01

/**
 * 描述： 操作运算符
 */
object Demo003_Operator {

  def main(args: Array[String]): Unit = {

    println(7 + 3)
    println(7 - 3)
    println(7 * 3)
    println(7 / 3)
    println(7 % 3)

    println(7 > 3)
    println(7 >= 3)
    println(7 < 3)
    println(7 <= 3)
    println(7 == 3)
    println(7 != 3)

    println(true && false)
    println(true || false)
    println(!false)

    println(7 & 3) // 0111 & 011
    println(7 | 3) // 0111 & 011
    println(7 ^ 3) // 0111 & 011
    println(7 >> 1)
    println(7 << 1)
    println(-7 >>> 1)
    println(-7 >> 1)

    println(1 == 1)
    println(1 == 1.0)
    println("huangbo" == "huangbo")

    println("huangbo" equals "huangbo")
  }
}

控制台打印输出：

5、流程控制 if

代码实现：

package org.apache.scala.day01

/**
 * 描述:  流程控制 if
 */
object Demo004_If {

  def main(args: Array[String]) {

    // if条件分支是可以拥有返回值的。！！返回值为代码段中的最后一个局代码的返回结果
    var aa = 1
    var result = if (aa > 0) {
      println(">")
    } else {
      println("<")
    }
    println(result)

    val x = 1
    //判断x的值，将结果赋给y
    val y = if (x > 0) 1 else -1
    //打印y的值
    println(y)

    //支持混合类型表达式
    val z = if (x > 1) 1 else "error"
    //打印z的值
    println(z)

    //如果缺失else，相当于if (x > 2) 1 else ()
    val m = if (x > 2) 1
    println(m)

    //在scala中每个表达式都有值，scala中有个Unit类，写做(),相当于Java中的void
    val n = if (x > 2) 1 else ()
    println(n)

    //if和else if
    val k = if (x < 0) -1 else if (x > 0) 1 else 0
    println(k)
  }
}

打印输出

6、块表达式

代码实现：

package org.apache.scala.day01

/**
 * 描述:  块表达式
 */
object Demo005_BlockExpresstion {

  def main(args: Array[String]) {
    val x = 0
    //在scala中{}中课包含一系列表达式，块中最后一个表达式的值就是块的值
    //下面就是一个块表达式
    val result = {
      if (x < 0) {
        -1
      } else if (x >= 1) {
        1
      } else {
        "error"
      }
    }
    //result的值就是块表达式的结果
    println(result)

    //返回块中的最后一个表达式的值
    val aa = {
      1 to 10; if (3 > 2) 3 else 2
    }
    println(aa)

    val bb = {
      1 to 10; if (3 > 2) 3 else 2; val cc = 2
    }
    println(bb)
  }
}

打印输出：

7、流程控制 for

代码实现：

package org.apache.scala.day01

/**
 * 描述:  流程控制 for
 */
object Demo006_For {

  def main(args: Array[String]) {
    //for(i <- 表达式),表达式1 to 10返回一个Range（区间）
    //每次循环将区间中的一个值赋给i
    for (i <- 1 to 10)
      println(i)

    //for(i <- 数组)
    val arr = Array("a", "b", "c")
    for (i <- arr)
      println(i)

    // 倒序打印
    for (str <- arr.reverse) {
      println(str)
    }

    // 使用数组下标的方式进行打印
    for (i <- 0 to arr.length - 1) {
      println(arr(i))
    }

    for (i <- 0 until arr.length)
      println(arr(i))

    println("-----------------")
    for (i <- 0 until(arr.length, 2))
      println(arr(i))

    //高级for循环
    //每个生成器都可以带一个条件，注意：if前面没有分号
    for (i <- 1 to 3; j <- 1 to 3 if i != j)
      println((10 * i + j) + " ")
    println()

    //for推导式：如果for循环的循环体以yield开始，则该循环会构建出一个集合
    //每次迭代生成集合中的一个值
    val v = for (i <- 1 to 10) yield i * 10
    println(v)

  }
}

打印输出：

1
2
3
4
5
6
7
8
9
10
a
b
c
c
b
a
a
b
c
a
b
c
-----------------
a
c
12 
13 
21 
23 
31 
32 

Vector(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)

8、流程控制 break 和 continue

代码实现：

package org.apache.scala.day01
import util.control.Breaks._
/**
 * 描述:  流程控制 break 和 continue
 */
object Demo007_Break_Continue {

  def main(args: Array[String]): Unit = {

    // break 举例
    breakable(
      for (i <- 1 to 5) {
        if (i == 3) {
          break()
        }
        println(i)
      }
    )

    // continue 举例
    for (i <- 1 to 5) {
      breakable {
        if (i == 3) {
          break
        }
        println(i)
      }
    }

  }
}

打印输出：

9、流程控制 while

代码实现：

package org.apache.scala.day01

/**
 * 描述： 流程控制 while
 */
object Demo007_While {
  def main(args: Array[String]) {

    // Scala中的while的语法和java中的一样
    var n = 10;
    while (n > 0) {
      println(n)
      n -= 1
    }
  }
}

打印输出：

江湖侠客

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Scala基础篇【上】

1、Scala的HelloWorld程序代码实现：package org.apache.scala/** * 时间： 2021/7/16 8:40 * 描述： Scala的HelloWorld程序 * * 核心要点： * * 1、类名和文件名 * 2、main方法的定义(注意和java的main方法对比理解) * 3、分号(可有可无) * 4、编译和执行(scalac和scala) * 5、类的声明(object和class) */object Demo000_He.
复制链接

扫一扫