Scala入门(一) 基础语法

Scala入门(一)

1、scala概述

1.1 什么是scala

scala是一个具有面向对象编程和函数式编程的语言。运行于java虚拟机，并且兼容java程序。
www.scala-lang.org

1.2 为什么要学习scala

• 1、优雅
• 2、速度快
• 3、融合到hadoop生态圈

2、scala基础

2.1 声明变量

val a=1
var b=1

声明变量有2中方式，第一种val修饰，它相当于java中final，不可变，第二种是var修饰，可变
可以省略掉变量的类型，这个时候由scala编译器按照变量的值进行类型推断
当然可以手动指定变量的类型
val c:String="hello"
它是变量名在前，类型在后。

2.2 常用类型

Scala和Java一样，有7种数值类型Byte、Char、Short、Int、Long、Float、Double类型和1个Boolean类型。

2.3 条件表达式

就是在申明一个变量的时候，通过加上一些if elseif else这些逻辑，跟java基本上是一样
val a=1
val b=if(a<0) -1 else 1
val b=if(a<0) -1 else "hello"
val b=if(a<0) -1 else if(a==1) 0 else "hello"

2.4 块表达式

定义变量时用 {} 包含一系列表达式，其中块的最后一个表达式的值就是块的值。

val b={
     val c=a+1
     val d=c+1
     100
     }

2.5 循环

• for

  • 格式

    • for(变量名称 <- 集合/数组/表达式)

      for(i <- 1 to 10){
           if(i%2==0){
             println(i)
           }
           }
           
      for(i <- 1 to 10 if i%2==0) println(i)
      //相当于双层for循环
      for(i <- 1 to 3 ; j <- 1 to 3 if i!=j) println(i+10*j)
      //99乘法表
      for(i <- 1 to 9; j <- 1 to i){
            print(i+"*"+j+"="+i*j+"\t")
           if(i==j){
           println()
           }
           }
      //yield 生成一个新的数组
      for(i <- a if i%2==0) yield i*10
      

• while

  • while(返回结果是boolean类型的表达式)

2.6 定义方法和函数

• 定义方法

  def m1(x:Int,y:Int):Int=x+y
  m1(1,2)
  

• 定义函数

  val f1=（x:Int,y:Int）=>x+y
  f1(1,2)
  

• 方法和函数的区别

  • 函数是一个对象，这个函数有N个参数，就继承成FunctionN类
    • 它具备该对象中的一些方法
  • 方法就是对象中的方法，它是不具备函数这种特性。

• 方法转换成函数

  • 函数= 方法 _

3、数组

3.1 定长的数组

val array=new Array[Int](5)

val array=Array(1,2,3,4,5)

获取元素
array(下标)--------java是array[下标]

定长数组声明好之后它的长度是不可以发生改变--------就是不可以添加元素和删除元素

3.2 可变的数组

import scala.collection.mutable.ArrayBuffer
val array=new ArrayBuffer[Int]()

//添加元素
array += 1
array += (2,3,4)
array ++=Array(5,6)
array ++=ArrayBuffer(7,8)

//获取元素
array(下标)

//修改元素
array(0)= -1

//删除元素
array -= 1
array -= (2,3,4)
array --=Array(5,6)
array --=ArrayBuffer(7,8)

3.3 遍历数组

• for
  • for( i <- array) println(i)
  • for(i <- 0 until array.length) println(array(i))
  • for(i <- (0 until array.length).reverse) println(array(i))

3.4 数组操作

val array=Array(1,2,3,4,5,6,7,8)

for( i <- array if i %2==0) yield i
for( i <- array if i %2==0) yield i*10
val f1=(x:Int)=>x%2==0
array.filter(f1)
array.filter((x:Int)=>x%2==0)
array.filter(x =>x%2==0)
array.filter( _%2==0)

val f2=(x:Int)=>x*10
array.filter( _%2==0).map(f2)
array.filter( _%2==0).map((x:Int)=>x*10)
array.filter( _%2==0).map(x=>x*10)
array.filter( _%2==0).map(_*10)

4、映射

• 构建映射的方式

  • val map1=Map(键 -> 值,键 -> 值,键 -> 值)
  • val map2=Map((键，值)，(键，值)，(键，值)，(键，值))

• 获取map中的value

  • map1(键)
  • map1.getOrElse(键，默认值)

• 定义可变的map

  import scala.collection.mutable.HashMap
  val hmap=HashMap("zhangsan" -> 30,"lisi" -> 40)
  
  //获取key对应的value
  hmap(键)
  hmap.getOrElse(键，默认值)
  
  //添加和更新键值对
  hmap+=("wangwu" -> 60)
  hmap+=("wangwu" -> 80,"zhaoliu" ->70)
  hmap("lisi")=50
  
  //删除
  hmap -=("lisi")
  hmap.remove("zhangsan")
  

5、元组

• 通过小括号把不同类型的值聚在一起，我们称为一个元组

• 定义元组

  • val t=(元素，元素，元素，元素…)
  • val t=(“hadoop”,100,3.14)

• 获取元组中的元素

  • 通过_下标（下标从1开始）

    • t._1

    • t._2

    • t._3

6、scala中的List集合

• 1、定义不可变的list

  val list=List(1,2,3,4,5)
  

• 2、定义可变的list

  import scala.collection.mutable.ListBuffer
  val list=ListBuffer(1)
  
  //添加元素
  list +=2
  list.append(3)
  list.append(4,5)
  list ++=List(6,7)
  list ++=ListBuffer(8,9)
  
  //删除
  list -=1
  list --=List(2,3)
  list --=ListBuffer(4,5,6)
  

7、scala中的Set集合

• 1、不可变的set集合

  • val set=Set(1,2,3,4)

• 2、可变的set集合

  import scala.collection.mutable.HashSet
  val set=HashSet(1,2)
  
  //添加元素
  set +=3
  set.add(4)
  set++=Set(5,6)
  set++=HashSet(7,8)
  
  //删除元素
  set -=3
  set.remove(4)
  set --=Set(5,6)
  set --=HashSet(7,8)