Scala学习笔记1-基础介绍，读写文件，集合框架（Array,List,Tuple,Set,Map）

最近整理了电脑里关于scala中的笔记和资料，这里写点简要的小结。

1.scala的基础介绍

Scala是一种针对JVM 将函数和面向对象技术组合在一起的编程语言。
Scala火的原因：Scala是Spark和Kafka的原生语言。
scala拥有和java一样的数据类型，和java的数据类型的内存布局完全一致，精度也完全一致。
在scala中，val声明常量，var声明变量,def 函数声明
下面这张图是scala函数的一个简单案例：

操作符：scala中 a 方法 b 等同于 a.方法（b）例如：val sum=5+3 等同于 val sum=5.+(3)
还有一点注意的是，和java不同，Scala中没有++和—操作符，当需要递增或递减时，可采用：i+=1/i-=1
Scala中的打印语句： print(“”); println(“”); printf(“***”);

2.scala读写文件

2.1写入文本文件

scala中使用java.io.PrinterWriter实现把数据写入到文本文件中

import java.io.PrinterWriter
val out=new PrinterWriter(“D:\\scala\\output.txt”)
for(i <- 1 to 10) out.println(i)
out.close()

注意:必须要执行out.close()语句，才会看到output.txt文件被生成，如果没有执行out.close()语句，我们就无法看到生成的output.txt文件。

2.2读取文本文件

scala中可以使用Scala.io.Source的getLines方法实现对文件中所有行的读取

import scala.io.Source
val inputFile=Source.fromFile(“output.txt”)
val lines=inputFile.getLines  //返回的结果是一个迭代器
for(i <- lines) print(i)

3.函数简化

Scala中，可以不写return，如果不写return 则自动将最后计算的结果作为返回值，如果没有返回值，则函数的返回类型为Unit，类似于Java和C#中void。
简单点说：Unit等价于void,表示空类型
在scala内部 像python一样具有变量 函数类型推断机制，我们在声明一个变量时 不需要显示的去定义变量是何种类型，编辑器内部会自行进行判断。例如：
val x:Int=12
等价于 val x=12

4.集合框架

4.1 数组Array

在scala中，数组包括定长数组和不定长数组，默认是为定长数组（Imutable）
若要定义可变数组，需要显示导入包import scala.collection.mutable._
使用new来实例化一个类，当你创建一个对象的实例时，你可以使用数值或者类型。例如：val abc=new ArrayString
abc(0)=”aaaa” abc(1)=“bbb” abc(2)=”ccc”
for(i<- 0 to 2) println(abc(i))
也可以利用初始化数组简单的方法，与上例效果等同：val abc = Array(“aaa”,“bbb”,"ccc”)
以下我也写个demo便于理解：

import scala.collection.mutable.ArrayBuffer
object ArrayLearn {
  def main(args: Array[String]): Unit = {
    val arr = Array("scala", "spark","storm","flink") //定长数组
    val arrayBuf = ArrayBuffer[Int]() //这里定义的是可变数组

    arr(0)="hadoop";
    arr.toBuffer  //将定长数组转换为可变数组
    for(i <- 0 until  arr.length) //until不到arr.length 这里为正确表示，to会报错
      println(arr(i))   //遍历
    println("----------------------------")
    for (elem <- arr) {//遍历
      println(elem)
    }
    println("----------------------------")
    arrayBuf += 1 //可变数组可以用+=在尾端添加元素
    arrayBuf += (2, 3, 4, 5) //可变数组可以用+=在尾端添加多个元素
    arrayBuf ++= Array(6, 7, 8, 9, 10) //可变数组可以用++=在尾端添加任何集合
    println("arrayBuf:" + arrayBuf)
    arrayBuf.trimEnd(2) //移除最后的2个元素
    println("arrayBuf:" + arrayBuf)
    arrayBuf.remove(2) //移除下标为2的元素
    println("arrayBuf:" + arrayBuf)
    arrayBuf.remove(2, 4) //移除熊下标2元素开始的4个元素
    arrayBuf.toArray //将可变数组转换为不可变数组
    println("arrayBuf:" + arrayBuf)
  }
}

4.2 列表List

Scala的List和Java不同，不能被改变，这样做的一个好处是方法与方法之间关联性较小，从而方法变得更可靠和重用性高，使用这个规则也就意味着变量的设置是不可修改的，这也就避免了多线程访问的互锁问题。
:::方法表示连接两个列表，当然列表定义了::方法（右操作符），用于向列表添加元素

object ListLearn {
  def main(args: Array[String]): Unit = {
    val fruit=List("aaa","bbb","ccc")
    val num=List(1,2,3,4,5)
    val dim=List(List(1,0,0),List(0,1,0),List(0,0,1)) //这里是定义二维列表
    println("fruit: "+fruit)
    println("num: "+num)
    println("dim: "+dim)

    val num02=10::num //允许元素进行左添加 也就是向头部添加新的元素
    println("num02: "+num02)
    val num03=num:::num02   //使用:::操作符对不同的列表进行连接得到新的列表
    println("num03: "+num03)

    for(i <- num03) //for循环  逐个遍历 输出值
      print(i+" ")
    println()
  }
}

4.3 元组Tuples

Scala中另外一个很有用的容器类是Tupels， Tuples在方法需要返回多个结果时非常有用（Tuple对应数学的矢量的概念）
一旦定义了一个元组，可以使用._和索引来访问元组的元素（矢量的分量，注意和数组不同的是，元组的索引从1开始）例如：

val tuple = ("BigData",2015,45.0)
println(tuple._1) 	println(tuple._2)	

注意：定义一个List和Tuple，内部都可以包含不同的元素

4.4 集合（set）

集合（set）是不可重复元素的集合。列表中的元素是按照插入的先后顺序来组织的，但是，”集合”中的元素并不会记录元素的插入顺序，而是以“哈希”方法对元素的值进行组织，所以，它允许你快速地找到某个元素。
集合包括可变集合和不可变集合，缺省情况下创建的是不可变集合。
如果要声明一个可变集，则需要引入scala.collection.mutable.Set包。

/**
  * 集合（Set）简单运用
  * 集合包括可变集合和不可变集合，缺省情况下创建的是不可变集合
  * 这个demo创建的 不可变集合
  * @author xjh 2018.10.16
  */
object SetLearn {
  def main(args: Array[String]): Unit = {
    var mySet=Set("Hadoop","Spark")
    //因为是不可变集合 所以这里要用var定义变量 如果定义的是val会报错
    mySet+="Scala"
    println(mySet)    //这里原理实则和java的String一样 在内存中开辟一个新的内存空间存放数据
    println(mySet.contains("Spark"))
  }
}

import scala.collection.mutable.Set
/**
  *可变集合 需要引入scala.collection.mutable.Set包
  * @author xjh 2018.10.16
  */
object SetLearn02 {
  def main(args: Array[String]): Unit = {
    val set=Set("abc","ABC")
    set+="123"
    println("set : "+set)
  }
}

4.5 映射(map)

在Scala中，映射(Map)是一系列键值对的集合，也就是，建立了键和值之间的对应关系。在映射中，所有的值，都可以通过键来获取。
映射包括可变和不可变两种，默认情况下创建的是不可变映射，如果需要创建可变映射，需要引入scala.collection.mutable.Map包

/**
  * 映射map包括可变和不可变两种，默认情况下创建的是不可变映射。
  *  如果需要创建可变映射，需要引入scala.collection.mutable.Map包
  * @author xjh 2018.10.16
  */
object MapLearn {
  def main(args: Array[String]): Unit = {
    println("---------------不可变map------------------")
    val bigData = Map("scala" -> 35, "Hadoop" -> 30, "spark" -> 40)
    println(bigData)
    println(bigData("scala")) //map中通过key获得value
    println(bigData.contains("Hadoop")) //是否包含给定的值
    println(bigData.getOrElse("spark001", 70)) //通过key获得值，如果不包含给定key，则返回给定的值
    println(bigData.mkString("{", ",", "}"))
    println(bigData.drop(2))

    println("---------构造可变集合----------")
    val bigDataVar = scala.collection.mutable.Map("scala" -> 35, "Hadoop" -> 30, "spark" -> 50)
    println(bigDataVar)
    bigDataVar("spark") = 100 //更新键值对，如果不存在则添加
    bigDataVar += ("Kafka" -> 90) //使用+=添加
    for ((k, v) <- bigDataVar) {
      print(k + ":" + v+"; ")
    }
    println()
    for (a <- bigDataVar.keySet) {
      println(a) //只输出key
    }
  }
}

下一篇写scala中 有关 类与对象 函数式编程
参考文献：子雨大数据之Spark入门教程（Scala版）