Scala编程（一）

Scala编程（一）

Scala的特点

Scala是一种多范式的编程语言，其设计的初衷是为了集成面向对象和函数是编程的各种特性，Scala运行于Java平台（Java虚拟机），并兼容现有的Java程序（Scala源代码会被编译成Java字节码，它可以运行于JVM之上，并可以调用现有的Java类库）。

开发环境搭建

1.安装JDK

Scala源代码会被编译成Java字节码，它可以运行于JVM之上，并可以调用现有的Java类库）。

2.安装Scala

windows下安装

下载Scala

从 Scala 官网地址 http://www.scala-lang.org/downloads 下载 Scala

选用 .zip 的安装包下载

安装配置Scala

解压scala-2.11.8.zip到本地磁盘上

在环境变量中配置Scala的bin目录路径

检测是否安装成功

IDEA安装Scala插件

Configure -> Plugins -> Browse repositories ->
搜索 Scala 插件 -> OK -> 重启 IDEA

使用idea编写helloworld

object HelloWorld {
  def main(args: Array[String]): Unit = {
  	println("hello,world");
  }
}

Scala基础

基础语法需要了解以下几点：

数据类型、变量、if语句、条件表达式、块表达式、for语句

1.常用数据类型

Scala 与 Java有着相同的数据类型，

扫描二维码关注公众号，回复： 4471163 查看本文章

Scala的数据类型相当于Java中数据类型的包装类

2.声明变量

Scala的声明变量的格式：

var 变量名=初始值 val 变量名=初始值

var 变量名：数据类型=初始值 val 变量名：数据类型=初始值

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

    var i = 1   //声明时未指定类型Scala会自动判断
    val j : Int= 10   //声明时指定了数据类型

    println("i的值是：" + i)
    println(s"j的值是：$j")   //可使用$加变量名来获得变量的值

    i = 100   //修改用var定义的变量
    println(s"修改后的i值是：$i")

/*    j = 100
      使用var关键字声明的变量，可以对该变量的值进行修改
      使用val关键字声明的变量(相当于常量)，不可以对该变量的值进行修改
         */
  }
}

3.条件表达式

Scala中的常用表达式：和java中的三元运算符类似，但比他强大

Scala的表达式语法：

val result = if(比较运算表达式) 结果1 else 结果2

在给变量赋值时，可以直接使用单支if语句 或 双支if语句 或 多支if语句

例如： val result = if(num==10) 0 else if(num>10) 1 else -1

object demo2 extends App {
  val num = 2
  val result1 = if(num > 3) 1 else -1
  println(result1)
  //支持混合类型的表达式
  val result2 = if (num > 3) 1 else "error"
  println(result2)
  //if..else if.. else..
  val result3 = if (num >3) 1 else if (num <3) -1 else 0
  println(result3)
}

4.块表达式

定义变量时可以使用 {} 包含一系列表达式：

object demo3 extends App {
  val a = 10
  val b = 20
  val result = {   //该块表达式的最后一行表达式的值就是块的结果
    val num1 = a + b
    val num2 = b - a
    num1    //块表达式的结果值
  }
  println(result) //值为30
}

5.循环for语句

在scala中同样具有：for循环、while循环、do…while循环

for循环语法结构：

for (i <- 表达式/数组/集合)

object demo4 extends App {
  //循环取值
  for (i <- 1 to 10){   //区间1到10（包含1和10）
    println(i)
  }

  for (i <- 1 until 10){   //区间1到10（不包含10）
    println(i)
  }

  for (i <- 1 to 10 if i%3==0){   //添加守卫条件，满足守卫条件后才输出
    println(i)    //结果是3，6，9
  }

  //嵌套for
  for (i <- 1 to 5;j <- 6 to 10){
    println(i + "\t" + j)
  }
  //九九乘法表
  for (i <- 1 to 9 ;j <- 1 to 9 if i >= j){
    print(i + "x" + j + "=" + i*j + "\t")
    if (i ==j){
      println()
    }
  }
    
    //通过yield来操作for循环中的每一个值
  var a = for (i <- 1 to 10 ) yield i*10
  println(a)
}

while循环语法结构：

while(condition)
{
   statement(s);
}

object demo5 extends App {
  var a = 10
  while (a < 20){
    println(s"a的值为:$a")
    a =a + 1
  }
}

do…while 循环语法结构

do…while 循环与 while 循环类似，但是 do…while 循环会确保至少执行一次循环

do {
   statement(s);
} while( condition );

object demo5 extends App {
  var a = 10
  do {
    println(s"a的值为:$a")
    a =a + 1
  }while(a < 20)
}

函数

Scala语言具有函数式编程思想

函数的定义使用

def 函数名（参数1：类型，参数2：类型…）:返回值类型 = { 函数体代码实现 }

object demo6 extends App {
  //无参无返回的函数
  function()
  //Unit表示没有返回值
  def function():Unit = {
  println("没有返回值参数")
  }

  //有参数有返回的函数
  println(add(2,3))
  //不写返回值类型，程序会自行判断返回值类型
  def add(num1:Int,num2 :Int)={
    val sum = num1 + num2
    sum
  }
  //当函数的函数体代码只有一行是还可简写成如下的代码
  print(add2(3,4))
  def add2(num1:Int,num2 :Int) = num1 + num2

  //函数中的参数默认是使用val定义，不能对参数的值进行修改
  //匿名函数的左边是参数列表右边是函数体
  //匿名函数的语法格式：(参数:类型 , …)  =>  函数体
  print(sum(5,6))
  val sum = (num1:Int,num2 :Int) => num1 + num2

}

函数中的参数

默认参数：

在Scala中允许在定义函数时，给函数中的参数设定默认值。在调用函数时如没有给带有默认值的参数传值，则会

使用函数的默认参数值

格式：def 函数名(参数:参数类型=默认值 , 参数:参数类型=默认值) : 返回值类型 = { 函数体 }

带名参数：

一般情况下在函数调用时，函数的参数传递是按照函数定义时的参数顺序一个个传递。但是我们也可以通过指定函数参数名，并且不需要按照顺序向函数传递参数

在使用带名参数时，要求：调用的函数的中书写的参数名称必须和函数定义时所书写的参数名称保持一致

可变参数：

Scala 允许你指明函数的最后一个参数可以是重复的，即我们不需要指定函数参数的个数，可以向函数传入可变长度参数列表

语法格式： def 函数名（ 参数 : 参数类型*）: 返回值类型 = { … }

Scala 是通过在参数的类型之后放一个星号来设置可变参数(可重复的参数)

object demo7 extends App {
  printStrings("hadoop","spark","scala")
  def printStrings  (strs : String*) ={
    for (str <- strs){
      print(str + "\t")
    }
  }
}

数组、元组、集合

数组

Scala 语言中提供的数组是用来存储固定大小的同类型元素

数组的第一个元素索引为0，最后一个元素的索引为元素总数减1

语法格式1：

var 数组名: Array[元素类型] = new Array[元素类型](数组大小）

简化： var 数组名 = new Array[元素类型](数组大小）

语法格式2：

var 数组名 = Array(元素1,元素2,元素3,…)

说明：在Scala语言中，除了有不可变的数组外，还有可变数组

​ 不可变数组：数组的长度不能改变，但数组中存储的元素可以改变

​ 可变数组：数组的长度可以改变，数组中存储的元素也可以改变

数组的使用

object demo8 extends App {
  var arr = new Array[Int](3)
  //通过角标赋值
  arr(0) = 1;
  arr(1) = 2;
  arr(2) = 3;
  //遍历
  for (i <- arr){
    println(i)
  }

  //数组常用算法
  val arr1 = Array(1,3,5,4)
  //求和
  val sum = arr1.sum
  println(s"和为：$sum")
  //最大值
  val max = arr1.max
  println(s"最大值为：$max")
  //最小值
  val min = arr1.min
  println(s"最小值为：$min")
  //排序
  val arr2 = arr1.sorted  //默认升序 排序不会破坏元数组的顺序需要用新数组接收
  for (i <- arr2) print(i + "\t")
  println("\n------------")
  //从大到小
  val arr3 = arr1.sortWith(_>_)
  for (i <- arr3) print(i + "\t")
  println("\n------------")

  println(arr.mkString("|"))
  println(arr.mkString("start:","-","end"))
}

变长数组

掌握变长数组的定义及使用（当数组中所存储元素的个数不固定时使用变长数组）
Scala中的Array属于固定长度的数组，同样scala也提供了可变长度的数组：ArrayBuffer如果想使用数组缓冲，需要导入: import scala. collection. mutable. ArrayBuffer

import scala.collection.mutable.ArrayBuffer

object demo9 extends App {
  var arr = ArrayBuffer[Int]()
  //追加元素
  arr += 10
  arr.append(10)
  arr += (20,30,40)
  //追加数组
  arr ++= Array(50,60)
  arr ++= ArrayBuffer(100,200)
  //向数组指定的位置添加
  arr.insert(0, 8,9)
  //删除数组中的元素
  arr.remove(0)
  //删除从角标1开始向后取三个元素
  arr.remove(1,3)
  
  print(arr)
}

元组

Scala元组将固定数量的元素组合在一起，以便它们可以作为一个整体传递。与数组或列表不同， 元组可以容纳不

同类型的对象，但它们也是不可变的

元组可以理解为：是不同类型的值的聚集

元组的表示：通过将不同的值用小括号括起来，即表示元组

创建元组格式： val tuple = (元素,元素,…)

元组是类型Tuple1，Tuple2，Tuple3等等。 目前在Scala中只能有22个上限，如果您需要更多个元素， 那么可以

使用集合而不是元组

获取元组中的值格式：使用下划线加脚标 ，例如 t._1 t._2 t._3

注意元组中的元素角标是从1开始的

集合

Scala的集合有三大类： List、Set、Map(映射)，所有的集合都扩展自Iterable在Scala中集合有可变（mutable）和不可变（immutable）两种类型，immutable 类型的集合初始化后就不能改变了

list集合

不可变list集合

object demo10 extends App {
  val list = List[Int](1,2,3)
  //list(0) = 100   //报错
  println(list)
  /**
    * 在Scala中列表要么为空（Nil表示空列表）
    * 要么是一个head元素加上一个tail列表
    *
    */
  //定义一个空集合
  val list1 = Nil
  println(list1)
  //head:返回第一个元素
  println(list.head)
  //tail:返回除了第一个元素以外的其他元素
  println(list.tail)

  //list集合的使用
  //在list集合的头部添加新元素，并生成新的集合
  val list11 = 1 +: list
  println(list11)
  //把要添加的元素和原集合作为新集合的头和尾
  val list12 = 1 :: list
  println(list12)
  //在集合尾部添加新元素，并生成新的集合
  val list13 = list :+ 9
  println(list13)
}

可变list集合

import scala.collection.mutable._

import scala.collection.mutable.ListBuffer

object demo11 extends App {
  //集合基本使用
  val list = ListBuffer[Int](1,2,3)
  //追加元素
  list += 4
  list.append(5)
  //插入元素
  list.insert(0,0)
  println(list)
  //修改元素
  list(0) = 10
  //删除元素
  list.remove(0)
  list.remove(0,2)
}

合并集合

object demo12 extends App {
  val list1 = ListBuffer[Int](1,2,3)
  val list2 = ListBuffer[Int](4,5,6)
  //合并集合(追加到末尾)，不会产生新的集合
  list1 ++= list2
  println(list1)
  //合并集合生成新的集合
  val list3 = list1 ++ list2
  println(list3)
}

Set集合

不可变Set集合

Set代表一个没有重复元素的集合；将重复元素加入Set是没有用的，而且 Set 是不保证插入顺序的，即 Set 中的元素是乱序的。
定义格式 ： val set=Set(元素,元素,…)

object demo13 extends App {

  //不可变的set集合
  val set = Set(3,5,7,9)
  //添加元素,生成新的集合,重复的元素只有一个
  val set1 = set + (3,5,6)
  println(set1)
  //删除元素，生成新的集合
  val set2 = set - (5,6)
  println(set2)
  //集合合并
  val set11 = Set(1,2,3,4)
  val set12 = Set(3,4,5,6)
  val newSet = set11 ++ set12
  println(s"集合的并集为$newSet")
  //集合的交集
  val newSet1 = set11 & set12
  println(s"集合的交集为：$newSet1")
}

可变的set集合

object demo14 extends App {
  val set = mutable.Set(3,4,5)
  //添加元素(不会生成新的集合)
  //重复元素不添加
  set.add(4)
  set.+=(6)
  println(set)
  //删除元素
  //使用remove，返回布尔类型的结果
  println(set.remove(0))
  set.-=(3)
  println(set)
  //合并集合(不生成新的集合)
  val set1 = mutable.Set(1,2,3)
  val set2 = mutable.Set(3,4,5)
  set1.++=(set2)
  println(set1)
}

Map集合

定义Map集合：
val map=Map(键->值 ，键->值 ，…)

val map=Map((键，值), (键，值) , (键，值) , …) //利用元组构建

不可变Map集合

object demo15 extends App {
  //不可变的Map集合(操作时都会产生新的Map集合)
  val map = Map("sh"->"shanghai","bj"->"beijing")
  //添加,修改都可用
  val map1 = map.+("tj"->"tianjin")
  println(s"map1集合：$map1")
  //删除
  val map2 = map.-("sh")
  println(s"map2集合：$map2")
  //获取元素
  val value : Option[String]= map.get("bj")
  //val value = map("bj") 直接使用Key
  println(s"value的值为：$value")
}

Scala Option(选项)类型用来表示一个值是可选的（有值或无值)。
Option[T] 是一个类型为T的可选值的容器：
如果值存在， Option[T] 就是一个 Some[T]
如果不存在， Option[T] 就是对象 None

遍历和合并

object demo16 extends App {
  val map1 = Map("sh"->"shanghai","bj"->"beijing")
  val map2 = Map("sh"->"shanghai","nj"->"nanjing")
  //遍历
  for (k <- map1.keys){
    println(s"Key值为：$k")
    print(s"value值为：" + map1(k))
  }
  map2.keys.foreach(k =>{
    println(s"Key值为：$k")
    print(s"value值为：" + map2(k))
  })

  //合并集合
  //末尾添加
  val newMap1 = map1.++(map2)
  println("末尾添加"+newMap1)
  //头部添加
  val newMap2 = map1.++:(map2)
  println("头部添加"+newMap2)
 }

可变Map集合

import scala.collection.mutable

object demo17 extends App {
  val map :mutable.Map[String,Int]= mutable.Map()
  //添加kv元素
  map("lisi") = 12
  map.put("zhangsan",20)
  map.+=("wangwu"->13)
  //删除元素
  map.remove("lisi")
  map.-=("wangwu")
  println("map集合："+ map)
}