scala学习（一）

scala是纯粹的面向对象语言，每一个操做都是方法调用。

scala也是函数式编程语言，它有两种理念：一、函数式头等值，在函数式语言中，函数也是值，与整数或字符串处于同一个地位。函数能够被看成参数传递给其余函数。二、程序的操做应该把输入值映射为输出值而不是就地修改数据。

scala有不可变的列表、元组、映射表和集。

scala调用java中string对象中toInt方法是发现没有，它会将java的String对象隐式转换成Scala中的RichString对象，RichString有toInt方法。

1、变量定义

scala有两种变量：var和val，val相似于java里面的final变量。一但初始化了，val就不能再被赋值了。

*在java里，返回的值得类型称为返回类型，在scala里面称为结果类型。

*scala中的<-符号表明“其中”。若是要读for(arg<-args)，就读作“对于args中的arg”。

*不写new List，由于“List.apply()”是定义在scala.List伴生对象中的工厂方法。

Nil是空列表的简写同List()

2、列表List的经常使用方法 

val t = "Will" :: "fill" :: "until" :: "Util" :: Nil

println(t(2))              //返回t列表上索引为2（基于0）的元素，值为until

println(t.count(s => s.length == 4))   //计算长度为4的string元素个数为3

println(t.take(2))   //返回前2个元素的t列表,值为List("Will","fill")

println(t.takeRight(2))  //返回后2个元素的t列表,值List("until","Util")

println(t.drop(2))       // 返回去掉前两个的t列表，值为List("until","Util")

println(t.dropRight(2))      //去掉后两个元素的t列表，值为List("Will","fill" )

println(t.exists(s => s == "until"))    //判断是否值为"until"的字符串元素在t列表你,值为：true

println(t.filter(s => s.length == 4))   //返回长度为4的元素依次组成的新列表，值List("Will","fill","Util")

println(t.forall(s => s.endsWith("l")))  //判断是否t列表里面全部元素都一"l"结尾，值为：true

t.foreach(s => print(s))    //对t列表每个元素执行print语句，值为："WillfilluntilUtil"

t.foreach(print)     //于上相同，不过更简洁(同上)

println(t.head)      //取第一个元素

println(t.last)        //取最后一个元素

println(t.tail)        //取除去列表第一个元素的其余全部元素组成的列表

println(t.init)        //取除去列表最后一个元素的其余全部元素组成的列表

println(t.isEmpty)     //判断列表是否为空，为空true，不为空false

println(t.length)        //返回列表元素数量

println(t.map(s => s + "y"))     //对列表中每一个元素都作一次表达式计算，并返回一个新的列表

println(t.mkString(","))            //将列表元素以，号隔开组成一个字符串

println(t.reverse)                     //倒转这个列表的元素

//println(t.remove(s => s.length == 4))

println(t.filterNot ( s => s.length() == 4 ))      //过滤出元素长度不是4的，元素并返回，值为：List("until")

//println(t.sort((s,t) => s.charAt(0).toLowerCase < t.charAt(0).toLowerCase))

println(t.sortWith((s,t) => s.charAt(0)< t.charAt(0)))   //将元素按默认排序。

println(t.partition(s=>s.length == 4))  //将元素分红知足条件长度等于4的一个list与一个不知足条件的一个list

println(t.find(s=>s.length == 4 )) //将返回第一个知足条件的元素.并包装成option类型

println(t.span(s.startsWith("W")))  //span是遍历每个元素是否知足传入函数的条件,直到不知足的返回2个集合.(List("Will"),List("fill","until","Util")),这个函数太恶心了不知道有什么用能够自行测试

println(t.takeWhile(s.startsWith("W")))  //从第一开始直到返回false的那个元素.返回从第一个开始全部判断为true的元素

println(t.takeWhile(s.dropWith("W")))   //从第一开始直到返回false的那个元素.返回从第一个返回false的元素以后的全部元素

val  i = "SB" :: t   //加入一个元素返回一个新的列表

takeWhile (...)           等价于：while (...) { take }

dropWhile (...)           等价于：while (...) { drop }

span (...)          等价于：while (...) { take; drop }

3、集Set经常使用方法

var jetSet = Set("SB","MB")

jetSet += "NB"  //加入一个元素返回一个新的集

println(jetSet.contains("NB"))  //true

4、元组（Tuple）

var pair = (99,"test")

println(pair._1)//访问索引为一的元素。元组的索引从1开始

println(pair _2)

5、Map

var treasureMap = Map[Int,String]()

treasureMap += (1->"test") //添加一个key为1，value为"test"的值

treasureMap(1) //获取key为1的，value的值："test"

treasureMap.getOrElse("key",0)  //若是存在着返回这个key的value，若是不存在这个key返回一个给定默认值0

可变map：val map = new collection.mutable.HashMap[String,Int] 

                 新增一个键值对：map("key") = 1 或 map += ( "key" -> 1)

不可变map：var map = new collection.mutable.HashMap[String,Int] //必须的var的

                 新增一个键值对： map += ( "key" -> 1)

已排序map：var map = collection.SortedMap[String,Int]()    //不能够new它是一个抽象的

                  新增一个键值对： map += ( "key" -> 1)

Option类型的值一般做为Scala集合类型（List,Map等）操做的返回类型。 好比Map的get方法

6、Array、List、Set、Map、Tuple的异同

Array、List索引都是基于0的，Tuple索引是基于1的。

Array、List、Set、Map他们只能放入指定类型，Tuple能够放入任意类型。

 

随机生成字符串：BigInt.probablePrime(100,util.Random).toString(36)

import StringOps

charAt(0)下标为0的字符变成char类型(基于0)

take(n)               从左到右取n个

takeRight(n)      从右到左取n个

drop(n)              除去前n个返回剩余的String

dropRight(n)     除去后n个返回剩余的String

 

7、ArrayBuffer或Array

import scala.collection.mutable.ArrayBuffer

val a = ArrayBuffer[Int]()

a.updte(0,0) 或者 a(0) = 0   //修改下标为0的元素

a += 1                      //向数组中添加元素

a ++= Array(1,2,3)   //++=操做符能够添加任何集合

a.trimEnd(2)             // 移除最后2个元素

a.insert(2,4)              //在下标为2的位置插入4

a.insert(2,5,6,7)        //在下标为2的位置插入多个元素5,6,7

a.remove(2)             //移除下标为2的上的元素

a.remove(1,2)             //移除索引从1开始,删除2个元素

a.count( _ > 0 )       //清点有多少的正元素 

a.sum  //计算元素的和

a.max  //取出最大值

a.min   //取出最小值

a.toArray                  //转换成Array

ArrayBuffer(1,2,3).copyToArray(Array(4,5))   //左边会覆盖又遍的对应下标的元素。而且左边要是右边Array的超类

 1>Array

val a = Array[Int](10)         //这样建立时建立一个长度为1的定长数组，这个数组里面发的是10

val a = new Array[Int](10)      //new是建立一个长度为10的定长数组，默认值所有是0

val  arrayToMap = Array(("1",1),("2",2)).toMap

a.toBuffer          //转换成ArrayBuffer

scala.util.Sorting.quickSort(a)            //a要是Array，它会修改a自己。

a.sortWith(_ < _)   //对a进行从小到大排序，返回一个新的Array，不会修改原有的Array

a mkString(",")    //一","号分割每一个元素返回这个逗号链接的字符串

a mkString("<",",",">")    //重载的方法，给先后加上指定开始符号和结束符号

8、多维数组

val arrays = Array.ofDim[Double](x,y)  //x行，y列

建立一规则多维数组

val arrays = new Array[Array[Int]](10)

for(i <- 0 until arrays.length){

    arrays(i) = new Array[Int](i+1)

}

**拉链操做

StringOps中的zip定义以下 

abstract def zip[B](that: GenIterable[B]): StringOps[(A, B)] 

GenIterable是可遍历对象须要包含的trait，对于String来讲，它是可遍历的。可是它的遍历是遍历单个字母。 所

以拉链就针对每一个字母来进行。