scala数据类型 元组 数组 集合 Set Map

scala的变量和常量

类型推断

1. Scala编译器可以推断出表达式的类型，因此不必显示声明。减少自动类型推断可以提高代码的阅读性。

var a=1			//直接赋值
var a:Int=_		//不赋值用下划线

scala数据类型
总体上分为两类
值类型与引用类型的区别

1. 值类型：直接储存值，在栈上储存值
2. 引用类型：储存对其值的引用，在栈上储存地址，在堆上储存值

变量 var 变量名称:变量类型=值
常量 val 变量名称:变量类型=值
别名 type

raw //输入原始字符 不进行转义

object HelloWorld{
def main(args:Arrary[String]):Unit={
	println("Hellow World!")
	}
}

scala 程序控制

if else

val x=10
val y=if(x==10)x+1 else x

for 循环

for (i<- 表达式) {
statements
}

1 to n: 返回 1 到 n 的区间,包含 n
1 until n: 返回 1 到 n 的区间,不包含 n
1 to 10 by 2：返回 Range(1, 3, 5, 7, 9)
1 until 10 by 2：返回 Range(1, 3, 5, 7, 9)
变量<-表达式”也称为生成器

条件过滤

1. 标椎格式

val num=10;
for(i:Int<- 1 to num;if(i%2==0))
{
print(i * 100);
}

2. 简化格式

for(i:int<- 1 to num if i%2==0) println(i*100)

3. 更多守卫

for(i:Int<- 1 to num if i%2==0;if i>2) println(i*100)

多生成器

for(i<-1 to 5 if i%2==0;j<-1 to 5 if j%2!=0) println(s"$i+$j=$(i+j)")

Scala 中有这样一个编程风格, 如果 “()” 中有多个表达式的话, 可以使用“{}” 代替 “()”来写一个块表达式

for{i<-1 to 5 if i%2==0
	j<-1 to 5 if j%2!=0}
	println(s"$i+$j=$(i+j)")
//或者
for{i<-1 to 5 if i%2==0;j<-1 to 5 if j%2!=0} println(s"$i+$j=$(i+j)")

中断

import scala.util.control.Breaks._ //注意先导入
breakable { //调用 breakable()函数，op:=>Unit 表示无参函数
 for (i <- 1 to 10) {
 if (i == 5) {
 break() //调用 break()函数
 }
 println(i)
 }
}

或者

import scala.util.control.Breaks._
for (i <- 1 to 10) {
 if (i == 5) {
 break //调用 break()函数，无参数可省略“()”
 }
 println(i)
}

for推导式

val j=for(i:Int<-1 to 5;if i%2==0) yield i

for(a<-j){println(a)} //遍历

数组

//有界数组
var a1:Array[Sting]=new Array[String](3) //创建数组
a1(0)="jason"							 //赋值

//变长数组
var a2=new scala.collection.mutable.ArrayBuffer[Int]()
a2.appebd(1)	//添加数据
a2.append(2)
a2+=3			//添加数据并输出数组

数组的创建

var a1:Array[Sting]=new Array[String](3)
var a2=Array("js","jd")
var a2=Array.range(1,10,2)	//区间数组 从1到10 步数为2
var a2=new scala.collection.mutable.ArrayBuffer[Int]()

元组

元组的三个声明方式

var tp1 =("ma","mw")

var tp1=new Tuple3("mike","abje")

def mike="mike" ->5

//取值
t1._1
//打印元组
println(tp1_1)
//遍历1
tp1.productIterator.foreach{i=>println("value="+i)}
//遍历2
for（i<-t1.productIterator）println(i)

集合

在集合左右加元素/集合

    var c=List[String]("a","b","c")
    var x='x'+:c	//x a b c
    var y=c:+"y"	//a b c y
    for (s<-x)print(s+" ")
    for (s<-y)print(s+" ")

	import scala.collection.mutable._

    var lib=ListBuffer[Int](1,2,3,4)
    0+=:lib
    lib+=5
    List[Int](-2,-1)++=:lib
    for (s<-lib)print(s+" ")
    
    -2 -1 0 1 2 3 4 5

    var l=List("a","b","c","d","e")
    l.grouped(3).foreach(println)
    //结果
    List(a, b, c)
	List(d, e)

合并数组 筛选奇数 排序

    var i=Array[Int](1,5,2,7)
    var j=Array[Int](3,9,4,6)
    var a=List.concat(i,j)    //将两个数组连接为一个集合
    var b=i++j;               //将两个数组连接为一个数组
    for(s<-a)print(s+" ")     //遍历集合
    println()
    println(a.filter(_%2!=0)) //筛选奇数 List(1, 5, 7, 3, 9)
    println(a.sorted)         //升序		List(1, 2, 3, 4, 5, 6, 7, 9)
    println(a.sorted(Ordering.Int.reverse)) //降序	List(9, 7, 6, 5, 4, 3, 2, 1)
    println(a.sortWith(_<_))                //<升序 >降序 	  List(1, 2, 3, 4, 5, 6, 7, 9)
    println(a.sortBy(x=>x*(-1)))            //x升序 x*(-1)降序 List(9, 7, 6, 5, 4, 3, 2, 1)

Set

var s =Set("a","b")	//创建set
s+="c"				//添加元素
s-="a"				//减去元素
var x=Set（"q","w","a","b"）
t--s				//减去集合
t++s				//添加集合
SortedSted			//排序

var s=Set(1,2,3)
var t=Set(1,4,5)
t & s 			//交集
t tintersect s 
t|s				//并集
t union s		
t &~ s			//差集
t diff s

Map

var m=Map[string,Int]=Map[String,Int]("a"->1,"b"->2)
m("a")				//取值
m+=("j"->3)			//添加键值对
m-=("a")			//减去键值对
m.foreach(println)	//遍历并换行
var n=m++Map[String,Int]("b"->2,"c"->4)	//添加一个Map