scala类型介绍和使用

常用类型介绍

Scala有8种数据类型：Byte、Char、Short、Int、Long、Float、Double以及Boolean。

    

Boolean	true 或者 false
Byte	8位, 有符号
Short	16位, 有符号
Int	32位, 有符号
Long	64位, 有符号
Char	16位, 无符号
Float	32位, 单精度浮点数
Double	64位, 双精度浮点数
String	其实就是由Char数组组成

与Java中的数据类型不同，Scala并不区分基本类型和引用类型，所以这些类型都是对象，可以调用相对应的方法。String直接使用的是java.lang.String. 不过，由于String实际是一系列Char的不可变的集合，Scala中大部分针对集合的操作，都可以用于String，具体来说，String的这些方法存在于类scala.collection.immutable.StringOps中。

由于String在需要时能隐式转换为StringOps，因此不需要任何额外的转换，String就可以使用这些方法。

每一种数据类型都有对应的Rich*类型，如RichInt、RichChar等，为基本类型提供了更多的有用操作。

常用类型结构图

Scala中，所有的值都是类对象，而所有的类，包括值类型，都最终继承自一个统一的根类型Any。统一类型，是Scala的又一大特点。更特别的是，Scala中还定义了几个底层类（Bottom Class），比如Null和Nothing。

1)  Null是所有引用类型的子类型，而Nothing是所有类型的子类型。Null类只有一个实例对象，null，类似于Java中的null引用。null可以赋值给任意引用类型，但是不能赋值给值类型。

2)  Nothing，可以作为没有正常返回值的方法的返回类型，非常直观的告诉你这个方法不会正常返回，而且由于Nothing是其他任意类型的子类，他还能跟要求返回值的方法兼容。

3)  Unit类型用来标识过程，也就是没有明确返回值的函数。 由此可见，Unit类似于Java里的void。Unit只有一个实例，()，这个实例也没有实质的意义。

数据结构

数据结构特点

Scala同时支持可变集合和不可变集合，不可变集合从不可变，可以安全的并发访问。

两个主要的包：

不可变集合：scala.collection.immutable

可变集合：  scala.collection.mutable

Scala优先采用不可变集合，对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本

不可变集合继承层次：

可变集合继承层次：

主要数据结构

    数组Array

1. 定常数组
   

   //定义
   val arr1 = new Array[Int](10)
   //赋值
   arr1(7) = 7
   或
   //定义
   val arr2 = Array(1,2)

2. 变长数组
   //定义
   val arr2 = ArrayBuffer[Int]()
   //追加值
   arr2.append(7) 
   //重新赋值
   arr2(0) = 14
3. 定长数组与变长数组转换
   arr1.toBuffer
   arr2.toArray
   
4. 多维数组
   //定义
   val arr3 = Array.ofDim[Double](3,4)
   //赋值
   arr3(1)(1) = 13.14
5. 与Java数组的互转
   Scal数组转Java数组：
   val arr4 = ArrayBuffer("1", "2","3")
   //Scala to Java
   import scala.collection.JavaConversions.bufferAsJavaList
   val javaArr = new ProcessBuilder(arr4)
   javaArr.command
   Java数组转Scala数组：
   import scala.collection.JavaConversions.asScalaBuffer
   import scala.collection.mutable.Buffer
   val scalaArr: Buffer[String] = javaArr.command()
   
6. 数组遍历
   for(i <- arr1)  println(i)

     元祖Tuple(不可变)

     元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据。

1. 元祖的创建
   val tuple1 = (1,2,3,4,"hehe")
   println(tuple1)
2. 元组的访问，注意从1开始而不是0
   val value1 = tuple._1
   println(value1)   
3. 元组的遍历
   for循环
    for (elem <- tuple1.productIterator) {print(elem)}
   foreach
    tuple1.productIterator.foreach(println(_))

     列表List

     如果List列表为空，则使用Nil来表示

1.  创建List
   val list1 = List(1,2)
   println(list1)
2. 访问List元素
   val value1 = list1(1)
   println(value1)
3. List元素的追加
   val list2 = list1 :+ 99
   println(list2)
   
4. List的创建与追加，符号::，注意结尾有Nil表示每个项都是一个整体
   val list3 = 1::2::3::list2::Nil
   println(list4)
   打印结果===> List(1,2,3,List(1,2,99))

     队列Queue

     队列数据存取符合先进先出策略

1. 队列的创建
   import scala.collection.mutable
   val q1 = new mutable.Queue[Int]()
   print(q1)
2. 队列元素的追加( += 是函数)
   q1 += 1
   println(q1)
3. 向队列中追加List
   q1 ++= List(2,3,4)
   println(q1)
   打印结果===> Queue(1,2,3,4)
4. 按照进入队列的顺序删除元素
   q1.dequeue
   
5. 塞入数据
   q1.enqueue(5,6,7)
6. 返回队列中的一个元素
   q1.head
   
7. 返回队列中最后一个元素
   q1.last
8. 返回队列中除第一个以外的元素
   q1.tail

     映射Map

1. 构造不可变映射
   val map1 = Map("Alice" -> 10, "Bob" -> 12)
2. 构造可变映射
   val map2 = scala.collection.mutable.Map("Alice"->10, "Bob"->12)
3. 空的映射
   val map3 = new scala.collection.mutable.HashMap[String,String]
4. 对偶元组
   val map4 = Map(("Bob",12),("Alice",10))
5. 取值
   如果映射中没有值，则会抛出异常，使用contains方法检查是否存在key。如果通过 映射.get(键) 这样的调用返回一个Option对象，要么是Some，要么是None
   val value1 = map1("Alice")//建议使用get方法得到map中的元素
   
6. 更新值
   map2("Alice") = 20或map2+=("Alice"-> 20)或map2 -= ("Alice","Bob")或
   val map5 = map2 + ("AAA" -> 10,"BBB" -> 20)
   
7. 遍历
   for ((k, v) <- map1) println(k + " is mappedto " + v)
   for (v <- map1.keys) println(v)
   for (v <- map1.values) println(v)
   for(v <- map1) prinln(v)
   

     集Set

    集是不重复元素的结合。集不保留顺序，默认是以哈希集实现。如果想要按照已排序的顺序来访问集中的元素，可以使用SortedSet（已排序数据集），已排序的数据集是用红黑树实现的。默认情况下，Scala 使用的是不可变集合，如果你想使用可变集合，需要引用scala.collection.mutable.Set 包

1. Set不可变集合创建
   val set = Set(1,2,3)
2. Set可变集合创建
   val mutableSet = scala.collection.mutable.Set(1,2,3)
3. 可变集合的元素添加
   mutableSet.add(4)
   mutableSet += 6
   // 该方法是返回一个新的Set集合，而非在原有的基础上添加
   mutableSet.+(5)
4. 可变集合的元素删除
   mutableSet -= 1
   mutableSet.remove(2)
   
5. 遍历
   for(x <- mutableSet)
   
6. Set更多操作
   

   序号	方法	描述
   1	def +(elem: A): Set[A]	为集合添加新元素，并创建一个新的集合，除非元素已存在
   2	def -(elem: A): Set[A]	移除集合中的元素，并创建一个新的集合
   3	def contains(elem: A): Boolean	如果元素在集合中存在，返回 true，否则返回 false
   4	def &(that: Set[A]): Set[A]	返回两个集合的交集
   5	def &~(that: Set[A]): Set[A]	返回两个集合的差集
   6	def ++(elems: A): Set[A]	合并两个集合
   7	def drop(n: Int): Set[A]]	返回丢弃前n个元素新集合
   8	def dropRight(n: Int): Set[A]	返回丢弃最后n个元素新集合
   9	def dropWhile(p: (A) => Boolean): Set[A]	从左向右丢弃元素，直到条件p不成立
   10	def max: A	查找最大元素
   11	def min: A	查找最小元素
   12	def take(n: Int): Set[A]	返回前 n 个元素