scala语法

 

1，声明一个可变变量

var mm:String = "emily";

     声明一个只读变量

val gg:String = "sam";

2，取两个字符串的交叉部分

"heoll".intersect("loppfg");//ol

3，计算

import scala.math._ //需要先导入包

pow(2,4)

min(5,3)

sqrt(3)

4，字符串操作

"distinct".distinct  //除去重复的字符

 "helro".take(2) //自左向右 取两位  结果：he

"helro".takeRight(2) //自右向左取两位

"helro".drop(3) // 自左向右去掉3位 

"helro".dropRight(3) //自右向左去掉3位  he

"carzy"*3 //字符串拷贝  carzycarzycarzy

"distinct"(4) //按下标取第5个元素

5,逻辑运算，不同于java，可以使用下列语法来返回某个值

   var s = if( 4==4){

      5

    } else{

      -5

    };

    println(s);//5

当无结果返回时，输出:()

 var s3 =if(3>Pi){

      "nod"

 }

       println("s3"+s3);

 

 

 

6，for循环

  

    for( t <-1 to 10){

      print(t+" "); //输出结果为1 2 3 4 5 6 7 8 9 10 0

    }

 

7,数组

    val nums = new Array[Int](10)//10个基数的数组，所以元素初始化为0

 

    val a = newArray[String](10)//10个元素的字符串数组，所有元素初始化为null

 

    val a2 =Array("hello","world");//长度为2的Array[String]，类型是推断出来的，已经提供初始值就不需要new

 

    a2(0) = "Goodbye" //Array("Goodbye",""world) ,使用()而不是[]来访问数组

 

    val b = ArrayBuffer[Int]()

    b += 1//ArrayBuffer(1),尾端添加元素

    b += (1,2,3,5)//ArrayBuffer(1,1,2,3,5)

    b ++= Array(8,13,21) //可以用++=操作符追加任何结合,ArrayBuffer(1,1,2,3,5,8,13,21)

 

    b.trimEnd(5)//ArrayBuffer（1,1,2）//移除最后5个元素

 

   b.insert(2,6)//ArrayBuffer(1,1,6,2)//在下标为2之前插入

    b.insert(2,7,8,9)//ArrayBuffer(1,1,7,8,9,6,2)

   b.remove(2)//ArrayBuffer(1,1,8,9,6,2)//移除掉下标为2的元素

   b.remove(2,3)//ArrayBuffer(1,1,2)//移除下标为2后面的3个元素

 

   //有时你需要构建一个Array,但不知道最终需要装多少元素，在这种情况下，先构建一个数组缓冲，然后调用：b.toArray(1,1,2)

    //反过来。a.toBuffer，可以将数组装换成一个数组缓冲

    //如果想要每两个元素一跳，可以让i这样来遍历

    for(i <- 0 until (b.length,2)){

      println(i+": "+b(i))

    }

 

    //until是RichInt类的方法，返回所有小于(但不包括)上限的数字

    //0 until 10实际是一个方法调用： 0.until 10Range(0,1,2,3,4,5,6,7,8,9)

 

    //如果要从数组的尾端开始，遍历的写法为：（0 untila.length）.reverse

 

    val arr = Array(2,3,5,7,11)

    val result = for(elem <- arr) yield2*elem

    //result是Array(4,6,10,14,22),for(...) yield讯哈创建了一个类型与原始集合相同的新集合。

         //如果你从数组出发，那么你得到的是另一个数组

    //如果你从数组缓冲出发，那么你在for(...)yield之后得到的也是数组缓冲

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

      print(" arr-"+i+"="+arr(i))

    }

    val secondResult = for(elem <- arr ifelem %2 == 1 )yield  2*elem  //Array(4,10,22)

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

      print("secondResult-"+i+"="+secondResult(i))

    }

     val br =ArrayBuffer(1,7,2,9)//定义一个数组缓冲

 

    val brmked =br.mkString("<",",",">") // <1,7,2,9>

   

    println(brmked.count(_> 0))//统计brmked中大于0的元素的个数

 

    //多维数组

    val matrix = Array.ofDim[Double](3,4);

    println(matrix(2)(1))//获取数组元素

    matrix(2)(1)= 42 //给数组元素赋值

        

       //定义一个变长数组,行和列的长度不一样，下面代码将输出99乘法口诀表  

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

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

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

    }

    for(i <- 1 until triangle.length){

      for(j <-1 until triangle(i).length){

        triangle(i)(j) = i*j

        print(triangle(i)(j) + "  ")

      }

      println()

    }

 

   //Scala缓冲被包装成了一个实现了java.util.List接口的java类的对象

    val command =ArrayBuffer("ls","-al","/home/cay")

    val pb = new ProcessBuilder(command);

    println(pb)//java.lang.ProcessBuilder@736e788c

 

   // val cmd:ArrayBuffer[String] =pb.command();

    //不能使用ArrayBuffer

 

  

 

    ///================================== 映射和元祖

 

    //构造一个映射,构造一个不可变的Map[String,Int]

    val scores = Map("Alice" -> 10,"Bob" ->26,"sam" ->24)

    //构造一个可变的映射

    val scores2 =scala.collection.mutable.Map("Alice" -> 10 ,"Bob"->26,"sam" ->24)

    //定义一个空的映射

    val scores3 = newscala.collection.mutable.HashMap[String,Int]

    //查找

    val samScore =scores("sam")   //当被查找的key不存在时，将抛出异常

    println(samScore)//24

 

    //检查映射是否包含某值

    val samScore2 =if(scores.contains("sam")) scores("sam") else 0

 

    println(samScore2)//读取24

       val BobScore =scores.getOrElse("Bob",0)//语法类似于 if...else

   

    scores2("Bob") =62 //修改值，将原来的26修改成62

   

    //添加元素,同事修改Bob的值

    scores2 += ("anly" ->18,"vien" ->20,"Bob" ->2)

   println("scores2->Bob"+scores2("Bob"))

    println(scores2("vien"))

    println(scores2.size)

    scores2 -= "Alice"

    println(scores2.size)

    //对一个不可变映射扩容，并生成新的映射，同时修改Bob

    println(scores.size)

    val newScores = scores + ("taily"-> 23,"Bob"->8)

    println(newScores.size)

   println("scores->Bob"+scores("Bob"))

   println("newScores->Bob"+newScores("Bob"))

   //val是不可变的，而var是可变的，只需要给res变量重新赋值就可以检测res是val还是var了

    var scores4 =newscala.collection.mutable.HashMap[String,Int]

    scores4 += ("taily" ->23,"Bob"->15)

    println(scores4.size)

    scores4 -= "Bob"

    println(scores4.size)

    //迭代map

    for((k,v) <- scores) {

      println(k+"->"+v)

    }

    //迭代key

    for(k <- scores.keySet){

      println(k)

    }

 

    //反转一个映射

    val reversedScores = for((k,v) <-scores) yield (v,k)

    for((k,v) <- reversedScores) {

      println(k+"->"+v)

    }

 

    //已排序映射

    val treeScores =scala.collection.immutable.SortedMap("anly" -> 18,"vien"->20,"Bob" ->2)

 

 

    //如果要按插入顺序访问所有键，使用LinkedHashMap,例如

    val months =scala.collection.mutable.LinkedHashMap("anly" ->18,"vien" ->20,"Bob" ->2)

    //和java互操作

    val scores5 :scala.collection.mutable.Map[String,Int] = new java.util.TreeMap[String,Int]

    val props :scala.collection.Map[String,String] = System.getProperties()

 

    for((k,v) <- props){

      println(k +" ——>"+v)

    }

 

    //构造元组（类型不同的一组数据），不同类型的集合

    val t = (1,3.14,"Fred")

    //用_1,_2,_3访问其组元，元组从1开始，而不是0

    val second = t._2  //3.14

  

   

    var partitionMap ="NewYork".partition(_.isUpper)//Tuple2

    println(partitionMap) //将大小写字母分组 输出结果：(NY,ew ork)

 

    //拉链操作

    val symbols =Array("<","-",">")

    val counts = Array(2,10,2)

    val pairs = symbols.zip(counts)

 

        //迭代paris的k,v输出结果：<&2  -&10  >&2

    for((k,v) <- pairs){  

      print(k+"&"+v)

    }

 

 

    //toMap方法可以将对偶的集合转换成映射

    val tranedTuple= pairs.toMap

    println(tranedTuple.getClass())  //classscala.collection.immutable.Map$Map3