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