Scala 学习

1、scala项目结构

2、"Hello World"第一个程序

object HelloWorld {
  def main(args: Array[String]): Unit = {
    println("hello world")
    System.out.println("aaaa")
  }
}

3、与Java程序对比

public class Student {
    private String stuname;
    private String stupwd;
    private static String school="aiaaiai";

    public Student(String stuname, String stupwd) {
        this.stuname = stuname;
        this.stupwd = stupwd;
    }

    public void printinfo(){

        System.out.println(this.stuname "   " this.stupwd "  " Student.school);
    }

    public static void main(String[] args) {
        Student nnn = new Student("nnn", "sss");
        Student iii = new Student("iii", "ooo");
        nnn.printinfo();
        iii.printinfo();
    }
}

4、变量、常量和数据类型

1、变量var、常量val：

package com.demo2

import com.demo1.Student
/**
 * @author June
 * @date 2022/1/24 16:31
 */
object Test2 {
  //声明一个变量的通用语法
  def main(args: Array[String]): Unit = {
    var a: Int = 3
    //声明变量时，类型可以省略，编译器自动推导、即——类型推导
    var a1 = 10   //Int类型：变量
    //类型一旦确定后，就不能修改、说明scala是强数据类型语言
    var a2 = 15   //
    //变量声明时必须要有初始值（Scala语言的特性之一）

    //错误定义方法 {：var a3:Int

    //在声明定义一个变量时，可以使用var或者val来修饰，
    // 1、var修饰的变量可改变、
    // 2、val修饰的变量不可改
    val a4 = 33
    //错误赋值： a4 = 83
    var ali  = new Student("sds",3)
        ali.printinfo()
        ali  = new Student("sssds",333)
        ali.printinfo()
    val alice  = new Student("sds",3)
        alice.printinfo()
        alice.name = "ni"
        alice.age = 5
        alice.printinfo()
  }
}

2、声明变量时的部分规则：

package com.demo2

/**
 * @author June
 * @date 2022/1/24 16:52
 */
/*
*   变量定义、方法定义、关键字
* */
object Test3 {
  def main(args: Array[String]): Unit = {
    //以字母或者下划线开头、后接字母、数字、下划线
    val hello: String= "wmnfdfdj"
    var helloe = ""
    val _abst = 333

/*  错误定义样例
    val h-b = ""
    val 2321sdf  = 2432
*/
    //以操作符开头、且只包含符（  - * / # !等）
    val - / = "hello"
    println(- /)
    //用反引号`....`包括任意的字符串、即使是Scala的关键字也可以
    val `id`:String = "isdfsd"
    println(`id`)
  }
}

3、笔记转载如下：
因为Scala的函数式编程要素，所以一个指导意见就是能用常量就不要用变量。

• 声明变量时，类型可以省略，编译器会自动推导。
• 静态类型，类型经过给定或推导确定后就不能修改。
• 变量和常量声明时，必须有初始值。
• 变量可变，常量不可变。

引用类型常量，不能改变常量指向的对象，可以改变对象的字段。

• 不以;作为语句结尾，scala编译器自动识别语句结尾。
• 标识符命名规范： 字母下划线开头，后跟字母数字下划线，和C/C /Java一样。
• 操作符开头，且只包含(±*/#!等)，也是有效的标识符。
• 用反引号包括的任意字符串，即使是同39个Scala关键字同名也可以。

5、字符串

• 类型：String
• 号连接
• *字符串乘法，复制一个字符串多次
• printf格式化输出
• 字符串插值：s"xxx${varname}"前缀s模板字符串，前缀f格式化模板字符串，通过$获取变量值，%后跟格式化字符串。
• 原始字符串：raw"rawstringcontents${var}"，不会考虑后跟的格式化字符串。
• 多行字符串：""" """。
• 输出：print printf println ...

package com.demo2

/**
 * @author June
 * @date 2022/1/25 9:12
 */
object Test4 {
  def main(args: Array[String]): Unit = {
    //字符串输出
    //字符串的拼接、println()用法：通过:赋值
    //字符串拼接：通过 链接
    val name = "alice"
    val age = 33
    println(age "岁的" name "在学习")
    //*用于将一个字符串复制多次拼接
    println(name*2)
    //println()：字符串。通过%传值
    printf("%d岁的%s在学习",age,name)
    println()
    //字符串的差值(模板)（差值字符串）通过$获取变量值
    println(s"${age}岁的${name}在学习")
    val num: Float = 2.33333445f
    println(s"The num is ${num}")         //格式化模板字符串s
    val nums: Double = 333232.33333445
    println(f"The num is ${nums}%.2f")    //格式化模板字符串f
    println(raw"The num is ${nums}%.2f")  //格式化模板字符串raw
    //三引号表示字符串、保持多行字符串的原格式输出
    val sql=s"""
       |select *
       |from
       |  student
       |where
       |  name = ${name}
       |and
       |  age > ${age}
       |""".stripMargin
    println(sql)
  }
}

测试结果：

6、输入

• StdIn.readLine()
• StdIn.readShort() StdIn.readDouble
• import scala.io.StdIn

package com.demo2

import scala.io.StdIn

/**
 * @author June
 * @date 2022/1/25 9:35
 */
object Test5 {
  def main(args: Array[String]): Unit = {
    //信息地输入
    println("请输入您的大名：")
    val name = StdIn.readLine()
    println("请输入您的年龄：")
    val age = StdIn.readInt()
    //控制台的打印输出
    println(s"欢迎${age}岁的${name}")

  }
}

测试结果：

7、读取文件

package com.demo2

import java.io.{File, PrintWriter}

import scala.io.Source

/**
 * @author June
 * @date 2022/1/25 9:40
 */
object Test6 {
  def main(args: Array[String]): Unit = {
    //从文件种读取数据
    Source.fromFile("src/main/resources/test.txt").foreach(print)

    //将数据写入文件
    val writer = new PrintWriter(new File("src/main/resources/output1.txt"))

    writer.write("hello scala from ni")
    //关闭输出流
    writer.close()

    Source.fromFile("src/main/resources/output1.txt").foreach(print)

  }
}

8、数据类型

• java基本类型char byte short int long float double boolean。
• java基本类型对应包装类型：Charater Byte Short Integer Long Float Double Boolean。
• java中不是纯粹的面向对象。
• Scala吸取了这一点，所有数据都是对象，都是Any的子类。
• Any有两个子类：AnyVal值类型 AnyRef引用类型。
• 数值类型都是AnyVal子类，和Java数值包装类型都一样，只有整数在scala中是Int、字符是Char有点区别。
• StringOps是java中String类增强，AnyVal子类。
• Unit对应java中的void，AnyVal子类。用于方法返回值的位置，表示方法无返回值，Unit是一个类型，只有一个单例的对象，转成字符串打印出来为()。
• Void不是数据类型，只是一个关键字。
• Null是一个类型，只有一个单例对象null就是空引用，所有引用类型AnyRef的子类，这个类型主要用途是与其他JVM语言互操作，几乎不在Scala代码中使用。
• Nothing所有类型的子类型，也称为底部类型。它常见的用途是发出终止信号，例如抛出异常、程序退出或无限循环。

整数类型：都是有符号整数，标准补码表示。

• Byte 1字节
• Short 2字节
• Int 4字节
• Long 8字节
• 整数赋初值超出表示范围报错。
• 自动类型推断，整数字面值默认类型Int，长整型字面值必须加L后缀表示。
• 直接向下转换会失败，需要使用强制类型转换，(a 10).toByte。

浮点类型：

• Float IEEE 754 32位浮点数
• Double IEEE 754 64位浮点数
• 字面值默认Double

字符类型：

• 同java的Character，2字节，UTF-16编码的字符。
• 字符常量：''
• 类型Char
• 转义：\t \n \r \\ \" \'etc

布尔类型：true false

空类型：

• Unit 无值，只有一个实例，用于函数返回值。
• Null 只有一个实例null，空引用。
• Nothing 确定没有正常的返回值，可以用Nothing来指定返回值类型。

package com.demo2

/**
 * @author June
 * @date 2022/1/25 10:10
 */
object Test7 {
  def main(args: Array[String]): Unit = {
    val a1: Byte = 127
    //错误定义:Byte 值范围 -128~127
    //val a2: Byte = 128
    val a2: Byte = -128
    //定义变量默认为整型
    val a3 = 12   //默认Int
    val a4: Long = 123444322222L    //长整型数值定义
    //错误定义
    val b1: Byte = 10
    val b2: Byte = (3 29)
    println(b2)

    val b3: Byte = (b1 33).toByte
    println(b3)

    //浮点类型
    val f1: Float = 1.2243f
    val d1:Double = 3.223

    //字符类型
    val c1: Char = 'a'
    println(c1)

    val c2: Char = '9'
    println(c2)
    //特殊字符
    val c3: Char = '\t'     //制表符
    val c4: Char = '\n'     //换行符
    println("abc"   c3   "def")
    println("abc"   c4   "def")

    //转义字符
    val c5 = '\\'         //表示\
    val c6 = '\"'         //表示"
    println("abc"   c5   "def")
    println("abc"   c6   "def")

    val i1: Int = c1
    println("i1:"   i1)
    val i2: Int = c2
    println("i2:"   i2)

    val c7: Char = (i1 1).toChar
    println(c7)
    val c8: Char = (i2-1).toChar
    println(c8)

  }
}

测试结果：

本人学习视频源：尚硅谷大数据技术之Scala入门到精通教程

这篇好文章是转载于：学新通技术网