scala快速上手

变量

// var | val 变量名 : 变量类型 = 变量值
//var username : String = “zhangsan”
//val password : String = “123456”

// 2. 类型推断,如果Scala能够自动推断出变量的类型，类型可以省略
var username = "zhangsan" // String
var age = 20   //Int
var salary = 10000.1  //Double


//3 .变量的初始化
/*
  Java变量的初始化:
    int a ;
    a = 1 ;  先声明后初始化
    int b = 2 ;  声明的同时初始化

  Scala变量的初始化
    var a : Int  = 1  声明的同时初始化 不可分开
 */

//4. 变量的可变 不可变
// 可变变量 var
// 不可变变量 val

var address : String = "beijing"

address = "shanghai"

println(address)

val sex : String = "male"

//sex = "female"

val引用指向的内存地址不能改变，但是里面的内容可变。
var引用指向的内存地址可变。而且定义时，必须初始化

标识符

Scala 可以使用两种形式的标志符，字符数字和符号。
字符数字使用字母或是下划线开头，后面可以接字母或是数字，符号"$"在Scala中也看作为字母。然而以"$“开头的标识符为保留的 Scala 编译器产生的标志符使用，应用程序应该避免使用”$"开始的标识符，以免造成冲突。
Scala 的命名规则采用和 Java 类似的 camel 命名规范，首字符小写，比如 toString。类名的首字符还是使用大写。此外也应该避免使用以下划线结尾的标志符以避免冲突。
Scala 内部实现时会使用转义的标志符，比如:-> 使用 $colon$minus$greater 来表示这个符号。

// 和Java一样的标识符命名规则
val name = "zhangsan" // OK
val name1 = "zhangsan0"   // OK
//val 1name = "zhangsan0" // Error
val name$ = "zhangsan1" // OK
val $name = "zhangsan2" // OK
val name_ = "zhangsan3" // OK
val _name = "zhangsan4" // OK
val $ = "zhangsan5"     // OK
val _ = "zhangsan6"     // OK
//val 1 = "zhangsan6"     // Error
//val true = "zhangsan6"  // Error

// 和Java不一样的标识符命名规则
val + = "lisi" // OK
val - = "lisi" // OK
val * = "lisi" // OK
val / = "lisi" // OK
val ! = "lisi" // OK
//val @ = "lisi" // Error
val @@ = "lisi" // OK
//val # = "lisi" // Error
val ## = "lisi" // OK
val % = "lisi" // OK
val ^ = "lisi" // OK
val & = "lisi" // OK
//val ( = "lisi" // Error
//val ( = "lisi" // Error
//val ) = "lisi" // Error
//val = = "lisi" // Error
val == = "lisi" // OK
//val [ = "lisi" // Error
//val ] = "lisi" // Error
//val : = "lisi" // Error
val :: = "lisi" // OK
//val ; = "lisi" // Error
//val ' = "lisi" // Error
//val " = "lisi" // Error
val "" = "lisi" // OK
val < = "lisi" // OK
val > = "lisi" // OK
val ? = "lisi" // OK
val | = "lisi" // OK
val \ = "lisi" // OK
//val ` = "lisi" // Error
val ~ = "lisi" // OK
val :-> = "wangwu" // OK
val :-< = "wangwu" // OK
// 切记，能声明和能使用是两回事

字符串

在 Scala 中，字符串的类型实际上就是 Java中的 String类，它本身是没有 String 类的。
在 Scala 中，String 是一个不可变的字符串对象，所以该对象不可被修改。这就意味着你如果修改字符串就会产生一个新的字符串对象。

2. 传值字符串
printf("%s is man,年龄是 %s",username,age)
注：必须是printf，不能换行，如果要换行还要再加\n或者空println（）
3. 插值字符串
println(s"$username is man ,age is $age")
4.多行字符串
object ScalaString {
def main(args: Array[String]): Unit = {
// 多行格式化字符串
// 在封装JSON或SQL时比较常用
// | 默认顶格符
println(
s"""
| Hello
| ${name}
“”".stripMargin)
}
}

这个|为顶到这一样的最前面

数据类型

Scala是完全面向对象的语言，所以不存在基本数据类型的概念，有的只是任意值对象类型（AnyVal）和任意引用对象类型(AnyRef)


自动类型转化（隐式转换）
object ScalaDataType {
def main(args: Array[String]): Unit = {
val b : Byte = 10
val s : Short = b
val i : Int = s
val lon : Long = i
}
}其实借用了方法BoxesRunTime.boxToInteger(s)

强制类型转化

Java语言
int a = 10
byte b = (byte)a
Scala语言
var a : Int = 10
Var b : Byte = a.toByte
// 基本上Scala的AnyVal类型之间都提供了相应转换的方法。

这是对于AnyValue来说，但是对于AnyRef，就不能使用该方法，因为你自定义的对象不一定有这个方法，此时使用
AnyRef ：
// isInstanceOf[类型] 判断对象是否是某个类型
// asInstanceOf[类型] 将对象转换成某个类型

// AnyRef ：
// isInstanceOf[类型] 判断对象是否是某个类型
// asInstanceOf[类型] 将对象转换成某个类型

val user : AnyRef = new User
val user1: User = user.asInstanceOf[User]

//先判断是否是某个类型
val bool: Boolean = user.isInstanceOf[User]
if(bool){
  val user11: User = user.asInstanceOf[User]
}

scala是完全面向对象的语言，所有的类型都提供了toString方法，可以直接转换为字符串
lon.toString
任意类型都提供了和字符串进行拼接的方法
val i = 10
val s = "hello " + i

运算符

val a = new String(“abc”)
val b = new String(“abc”)

println(a == b) // true
println(a.equals(b)) // true

如果是java中，因为重写了equals方法，所以equals比较的是地址值，这里便是true false，那么scala中如何比较对象的地址值呢？
// 比较对象的地址值
println(str1.eq(str2)) //false 简写 println(str1 eq str2 )

运算符本质：
在Scala中其实是没有运算符的，所有运算符都是方法。
1.scala是完全面向对象的语言，所以数字其实也是对象
2.当调用对象的方法时，点.可以省略
3.如果函数参数只有一个，或者没有参数，()可以省略

```java
object ScalaOper {
    def main(args: Array[String]): Unit = {
        val i : Int = 10
        val j : Int = i.+(10)
        val k : Int = j +(20)
        val m : Int = k + 30
        println(m)
    }
}

流程控制

if语句

if语句同java中用法一致，但是Scala中表达式是有返回值的，也就是可以给if语句赋值，如

```scala
var res =  if(age <18 ){
      "童年"
      10
    }else if( age <= 30 ){
      "青年"
    }else if(age <=50){
      "中年"
    }else{
      "老年"
    }
    println(res)

for循环

1)基本语法
for ( 循环变量 <- 数据集 ) {
循环体
}
这里的数据集可以是任意类型的数据集合，如字符串，集合，数组等
object ScalaLoop {
def main(args: Array[String]): Unit = {
for ( i <- Range(1,5) ) { // 范围集合
println("i = " + i )
}
for ( i <- 1 to 5 ) { // 包含5
println("i = " + i )
}
for ( i <- 1 until 5 ) { // 不包含5
println("i = " + i )
}
}
}

2)循环守卫
object ScalaLoop {
def main(args: Array[String]): Unit = {
for ( i <- Range(1,5) if i != 3 ) {
println("i = " + i )
}
}
}

3)循环步长
scala的集合也可以设定循环的增长幅度，也就是所谓的步长step
object ScalaLoop {
def main(args: Array[String]): Unit = {
for ( i <- Range(1,5,2) ) {
println("i = " + i )
}
for ( i <- 1 to 5 by 2 ) {
println("i = " + i )
}
}
}

4)循环嵌套

等同于 for ( i <- Range(1,5) ) {
for ( j <- Range(1,4) ) {
println("i = " + i + ",j = " + j )
}
}
}

这里可以体现scala的输出语句和java的不同，scala的输出语句更像是sql中的select from

5)引入变量
object ScalaLoop {
def main(args: Array[String]): Unit = {
for ( i <- Range(1,5); j = i - 1 ) {
println("j = " + j )
}
}
}

如，可以打印1到5互相乘的结果


练习：挑战用一个循环完成如下杨辉三角


这里可以看到，scala中的println很特殊，可以一次打印乘数个特殊数并且颠倒就不可以了
如可以println(“6” * 5)，一次打印5个6再换行，但是println( 5 * “6”)就会报错

跳出循环

中断循环
通过对整个代码体外面套用 Breaks.breakable{}
并且在需要中断循环的地方使用 Breaks.break()
如果不在代码外面套用 Breaks.breakable{}的话也会中断循环但是会抛出异常导致无法继续运行

中断当前循环可以利用 if！=来达到目的