scala 变量，集合

var 可变，可重新赋值，赋值为"_"表示缺省值(0, false, null)，例如：

	                var d:Double = _ // d = 0.0
			
			var i:Int = _ // i = 0
			
			var s:String = _ // s = null

val不可变

    val (x,y) = (10, "hello")

def 实时返回结果变量，可作为方法返回结果，方便使用

def t = System. currentTimeMillis // 每次不一样

类型转化：

1强转换

var i = 10.asInstanceOf[Double] //类型强制
println(i)
println(List('A','B','C').map { x => (x+32).asInstanceOf[Char] })

在强转换Array[Object]到Array[String]则会报错，建议arr.map{x=>x.toString//加上的处理什么的}

2.implicit隐式转化

  implicit def typeConvertor(input:Int):String = input.toString

  implicit def typeConvertor(input:Boolean):String = if(input) "true" else "false"

    display("1212")
    display(12)
    display(true)

3.表示Array转为普通序列

val options = parse(args2:_*)

  def parse(x:Int*) = {
    for(i <- x)
      println(i)
  }

----

集合

集合map方法：

//transation的map方法，seq，list，map...
    var arr1 = Seq(1,2,3,4,5)
    var maparr = arr1.map(p=>{
      p+10
    })

1.List是不可变的，Tuple可以包含不同元素

var arr2 = List(1,2,3,4,5,1)
println(arr2.map { case(a) => a+1})

2.Map

    var maptest = Map(1->2,3->4,5->6,1->5)
    println(maptest.map{case(k,v)=>k})

    //map 1是key，2是value
    println(maptest.map(_._1))
    println(maptest.map(_._2))

3.Seq 去重集合

     println(arr2(0))
     println(arr1(0))
     println((1,2,3)._1)
     var ttt = Set(1,2,3)
     ttt+=1

4.Array定长集合，可变内容，不变长度，和java交互式，一般集合转为此类

var pathList = new Array[String](list.size())
    for(i <- 0 to list.size()-1){
      pathList(i)=list.get(i)
    }
    pathList = pathList.map { x => path+pathSeperate+x }

5.ArrayBuffer 变长变内容的集合

private var cis=ArrayBuffer[(String,Option[ZkDTState],Option[String],Option[Array[String]])]();

    for(po <- list){
      var stat = readContent(zkclient,po._1+pathSeperate+pathContent,po._2)
      var nodes = readchildNodesInfo(zkclient, po._1+pathSeperate+pathNodes)
      var active = readChildActiveNodeInfo(zkclient, po._1+pathSeperate+pathActive)
      cis.+=((po._1,stat,active,nodes))
    }

6.集合的filter，groupBy方法：

println("相同的arr2元素分到一个组,并过滤大于1"+arr2.groupBy(groupm).filter{case(a,b) => (a>1)}.keys)

groupBy方法按照函数参数groupm分组

  def groupm[A](x:A):A=x;

将相同的元素分到一个组里，返回map[Int,List[Int]]

filter方法，（a,b）,a是groupBy返回的值Int，b是集合arr2中相同的元素集合List[Int]

最终过滤值大于1的，获得map的key

这一行的作用是去重

猜你喜欢