Scala 基础语法总结

Scala 是一门使用Java开发的编程语言， 就是披着Scala语法的Java

1.main 方法
Java 中写mian方法，直接写main 但Scala中不行

def main(args: Array[String]): Unit = {
  //def 相当于Java中的 public 
  //（）里面是参数列表
  // ：后面写函数返回类型
  //Unit 代表 ：无返回类型
}

object  HelloWorld extends App{
  println("hello world")
}

运行结果：

hello world

2.定义变量
在Java中定义变量时需要给出变量的类型，但Scala中不需要，因为 val 可以代表所有的类型

val num1=100	 //代表num1是Int型
val num2=100L 	//long
val num3=12.5F	 //float
val num4=12.5D	 //double

val bool1=true 	//boolean
val bool2=false	 //boolean

val c="abc" 	//String
val d='a'	 //Char

使用print查看一下我们写的是不是真的是我们想要的类型

println(num1.getClass)     //获取num1的类型
println(num2.getClass)
println(num3.getClass)
println(num4.getClass)

println(bool1.getClass)
println(bool2.getClass)

println(c.getClass)
println(d.getClass)

输出结果为：

int
long
float
double
boolean
boolean
class java.lang.String
char

所以证明我们是对的 ，灵活引用 val

3.变量之间强制转换
int 型变量可以直接转换成double型，但是double型转换成int型就要强制转换

val value : Int =12           //定义 一个int型 变量 value ， 值为12
val doubleValue :Double =value    //把int型变量转换为double类型，可以直接转换
    //变量名字    ：  变量类型 = 要转换的变量名字
val intValue :Int =doubleValue.toInt     //把 double 型变量强制转换成 int型

记住变量类型第一个字母都要大写

4.while循环
Scala里面的while 循环跟Java里面的循环是一样的

var count=0
while(count<10)
  {
  count+=1
  println(count)
  }

如果没有大括号，那么 println 只执行一次

5.录入键盘数据

while (true)
  {
    val b=new BufferedReader(new InputStreamReader(System.in))
    val line = b.readLine  //一定不要拉下这一句
    println("roboot:"+line.replace("？","!"))
  }

运行结果：

你好？
roboot:你好!

6.函数调用（写一个函数并在主函数里调用它）

def main(args: Array[String]): Unit = {
  getUserInfo(10001,"小明",98,87,85)  //调用了getUserInfo 函数

}
  def getUserInfo(ID : Int,userName : String ,scores : Int*): Unit ={
  //函数的名字    （参数列表 ，ID，userName,scores等，这里的* 代表 int 类型的score 可以有很多个）
    println("id:"+ID)
    println("name:"+userName)
    scores.foreach(println _)  //这里的 空格+— 代表循环输出
  }
}

要灵活引用* 和 foreach (增强for 循环)

7.权限使用
以前Java里面的权限类型有4种：

假设现在有一个名叫 com 的包 ，这个 com 包里还有一个名叫 web 的包：

private[this] val id : Int = 1001      //this :代表只能在当前类里面使用id这个类
private[com] val name : String ="小明" //只能在com 里面使用该变量
private[web] val age :Int=20          //只能在web里面使用该变量

8.if 语句
Scala里面的if 语句更灵活 ，使用起来更方便

val filename="flume-ng.conf"
val result =if (filename.endsWith(".conf")) true else false
println(result)

运行结果：

true

9.对集合（Map）的操作
Map(映射)是一种可迭代的键值对（key/value）结构。
所有的值都可以通过键来获取。
Map 中的键都是唯一的。
Map 也叫哈希表（Hash tables）。
Map 有两种类型，可变与不可变，区别在于可变对象可以修改它，而不可变对象不可以。
默认情况下 Scala 使用不可变 Map。如果你需要使用可变集合，你需要显式的引入 import scala.collection.mutable.Map 类
在Scala中你可以同时使用可变与不可变 Map,不可变的直接使用 Map,可变的使用 mutable.Map.以下实例演示了不可变 Map 的应用：
———————————————

def main(args: Array[String]): Unit = {
  //调用集合的包
  import scala.collection.mutable.Map
  val map =Map("Max" ->100,"Mike" ->98,"Lili" ->95)
  //添加元素
  map("Jack")=86
  //更新元素
  map("Mike")=60
  //删除元素
  map.remove("Jack")
  print(map)
  //迭代元素
  for(key <-map.keys)  //元素赋给谁，箭头就指给谁
    println(key)
  for(value <-map.values)
    println(value)
  for ((k,v)<-map)
    println((k,v))
}

有一点与Java不一样，那就是调用包的时候不用在main函数外调用，main里面就可以之家调用（比如上面这题的map函数）

运行结果：

HashMap(Mike -> 60, Max -> 100, Lili -> 95)Mike
Max
Lili
60
100
95
(Mike,60)
(Max,100)
(Lili,95)

10.头等函数（函数不用非得def开头，也可以用val 开头）

def main(args: Array[String]): Unit = {
  val print_var=(x:Int,y:Int) =>{
    println("x:"+x)
    println("y:"+y)
    x+y   //这是返回的意思，不用像Java一样写个return

  }
 println(print_var(10,30))
}

运行结果：

x:10
y:20
30

11.用val定义的变量是不可变的，被初始化后值就固定下来，不可以再被修改（这类似于java中的final关键字）；用var定义的变量是可变的，可以任意修改。

12.占位符

def main(args: Array[String]): Unit = {
  var list =List(1,2,3,4,5,6)
  list=list.filter(_ > 2) //输出下标为2或者大于2的元素 filter 是过滤器的意思
  list.foreach(println( _))
}

运行结果：

3
4
5
6

13.关于集合的操作 （太牛逼了，这个好好看）

 //创建一个list
  val lst0 = List(1, 2, 3, 4, 5, 6, 7, 8, 1, 5)
  //将lst0中的每个元素乘以10以后生成新的集合
  val ls2 = lst0.map(_ * 10)
  println(ls2)
  val ls3 = lst0.filter(_ % 2 == 0) //获取集合lst0中的偶数
  println(ls3)
  val ls4 = lst0.sortWith(_ > _) //将lst0从大到小排序赋值给ls4
  println(ls4)
  val ls5 = lst0.sortWith(_ < _) //从小到大排序
  println(ls5)
  val ls6 = lst0.sorted //默认排序，从小到大
  println(ls6)

  val aa = List("bob", "mike", "lucky", "jack").sortWith(_.length < _.length)
  println(aa)

  //反转顺序
  val res1 = lst0.reverse//把头放尾，尾放头
  println(res1)

}

运行结果：

//乘以10之后的值
List(10, 20, 30, 40, 50, 60, 70, 80, 10, 50)
List(2, 4, 6, 8)
List(8, 7, 6, 5, 5, 4, 3, 2, 1, 1)
List(1, 1, 2, 3, 4, 5, 5, 6, 7, 8)
List(1, 1, 2, 3, 4, 5, 5, 6, 7, 8)
List(bob, mike, jack, lucky)
List(5, 1, 8, 7, 6, 5, 4, 3, 2, 1)

14.快速调用元素

def main(args : Array[String]):
  Unit = {
    val t = (1001,"Mike",18)
    println("id:" +t._1) //把第一个元素赋给id,并输出
    println("name:" +t._2)
    println("age:" +t._3)
  }
	
}

运行结果：

id:1001
name:Mike
age:18

做完这些练习之后真心觉得Scala 太方便了，在Java使用排序这种代码块需要写很多行，在Scala中.sortwith 就实现了，真的太方便了。