Scala学习笔记——类型

1.Option类型

Option类型可以有两种类型，一种是Some(x)，一种是None对象

比如Scala的Map的get方法发现了指定键，返回Some(x)，没有发现，返回None对象

2.列表

List类型中的所有元素都具有相同的类型。

空列表的类型为List[Nothing]。对于任意类型T的List[T],List[Nothing]都是其子类。

val list = List[String]("1","2","3")
val list1 = "1"::"2"::"3"::Nil        //所有的列表都是由两个基础构造块Nil和::构造出来的，Nil表示空列表

列表的基本操作

head　　返回列表的第一个元素，仅能作用在非空列表上

tail　　返回除第一个之外所有元素组成的列表，仅能作用在非空列表上

isEmpty　　判断是否为空

列表模式

列表可以使用模式匹配做拆分

val List(a,b,c) = list1   //两个List的长度相等，里面的元素一一对应
val a1 :: b1 :: rest = list1  //如果不知道长度，还是用::来做匹配，rest会是一个List

List类的一阶方法

1.连接列表使用 :::

2.列表长度，length

3.head和tail，获得第一个和除了第一个之外的列表

last和init，获得最后一个和除了最后一个之外的列表

4.翻转列表，reverse

5.drop和take可以返回任意长度的前缀或后缀

6.splitAt可以在指定位置拆分列表

val list = List[String]("1","2","3")
println(list.splitAt(1))

7.apply实现了随机元素的选择，按下标选择元素

indices方法可以返回指定列表的所有有效索引值组成的列表

8.啮合列表：zip，zip操作可以把两个列表组成一个对偶列表

如果想把列表元素和索引值啮合在一起，可以使用zipWithIndex

9.显示列表：toString和mkString

val list = List[String]("1","2","3")
println(list.toString())
//输出 List(1, 2, 3)

val list = List[String]("1","2","3")
println(list.mkString("0",",","4"))   //前缀字符串，分隔符，后缀字符串
//输出 01,2,34

val buf = new StringBuilder
println("abcde".addString(buf,"{",";","}"))
#输出 {a;b;c;d;e}

10.转换列表：toArray、copyToArray

val arr = "abcde".toArray   //转换成Array
arr.foreach(print)

val l = "abcde".toList   //转换成List
l.foreach(print)

    val arr1 = Array[String]("1")
    val arr2 = Array[String]("0","0","2")
    arr1.copyToArray(arr2,1)　　　　　//把第一个arr的元素复制到第二个arr的相应位置
    arr2.foreach(print)　　　　　　　　//输出012

List类的高阶方法

1.列表间映射：map、flatMap和foreach

map把函数f应用在列表的每个元素之后生成的结果，组成一个新的列表，然后返回

    val words = List("Hello","World")
    println(words.map(_.toList))
    println(words.flatMap(_.toList))

//List(List(H, e, l, l, o), List(W, o, r, l, d))
//List(H, e, l, l, o, W, o, r, l, d)

2.列表过滤：filter、partition、find、takeWhile、dropWhile和span

filter过滤出符合条件的元素组成的列表

    val words = List("Hello","World")
    val filt = words.filter(_ == "Hello")
    println(filt)　　　　　　//输出 List(Hello)

partition返回列表对

    val words = List("Hello","World")
    val filt = words.partition(_ == "Hello")
    println(filt)        //输出列表对 (List(Hello),List(World))

find返回第一个满足条件的元素

    val words = List("Hello","World")
    val filt = words.find(_ == "Hello")
    println(filt)            //输出 Some(Hello)

takeWhile和dropWhile返回满足条件的最长前缀和最长后缀

span返回takeWhile和dropWhile的组合

列表的论断：

forall，如果列表中的所有元素都满足条件，返回true

exists，如果列表中有一个元素满足条件，返回true

    val filt = words.forall(_ == "Hello")
    println(filt)        //返回false

折叠列表　/:和:

    val result = ("" /: list) (_ + " " + _)   //初始值，加上每个值和间隔的结果
    println(result)        //返回  [ 1 2 3]

    val result = (list : "") (_ + " " + _)   //初始值，加上每个值和间隔的结果
    println(result)        //返回 [1 2 3 ]

列表排序

    val result = list.sortWith(_ > _)
    println(result)

List对象的方法

List.apply，通过元素创建列表

val list = List.apply("4","5","6")

List.range，创建数值范围，生成 List[1,2,3,4,5]

val list = List.range(1,6)

解除啮合列表，List.unzip

连接列表 List.concat

    val list = List[Char]('a','b','c')
    val list1 = List[Char]('z','x','c')
    val list2 = List.concat(list,list1)

    println(list2)    //输出    List(a, b, c, z, x, c)

3.集合类型

集合类型包括：数组（Array）、列表（List）、集（Set）、映射（Map）

    val list = List(1,2)

    val ite = list.iterator
    while (ite.hasNext) {
      println(ite.next())
    }

数组和列表是不可变对象，操作的时候使用buf来构造

队列（Queue）

添加元素——enqueue()

从头部移除元素——dequeue()

返回添加了元素之后的队列——append()

import scala.collection.mutable.Queue

    val empty = new Queue[Int]
    empty.enqueue(0)
    empty.enqueue(1)
    empty.enqueue(2)
    empty.dequeue()
    println(empty)

 栈和队列差不多

集（Set）

映射（Map）

元组，可以保存不同类型的对象

    val tuple = (1,"2")
    println(tuple._1)
    println(tuple._2)