scala元组和集合

Scala元组
*可以包含不同类型的元素
*最多支持22个元素
*使用下划线“_”访问元素，“_1”表示第一个元素
//元组声明方式一
var tp1=(“Mike”,“123 ABC”,58)
println(tp1._1)
println(tp1._2)
printlin(tp1._3)
//迭代元组
tp1.productIterator.foreach{i=>println(“Value=”+i)}

//元组声明方式二
var tp2=new Tuple3(“Mike”,“123 ABC”,58)

//元组声明方式三
“xjia”- >4 //(String Int)=(xia,4)

//将元组元素依次赋给三个变量
val(name,address,age)=tp1
println(name)
println(address)
parintln(age)

Scala集合-分类
*Seq 序列，元素按顺序排列
*Set 集合，元素不重复
*Map 映射，键值对集合

常用集合
名称 可变/不可变 示例
ArrayBuffer mutable val buffer = scala.collection.mutable.ArrayBuffer[Int](10, 20, 30); buffer+=(2,3)
Array mutable val arr=Array(1,2,3)
List immutable val lst=List(1,2,3)
Map mutable val stu= Map(“name” -> “Jason”, “age” -> “18”)
Set mutable/immutable val set=Set(1,2,3)
Vector immutable val v=Vector(1, 3, 5, 7, 11, 13)
Stack mutable/immutable val st=scala.collection.mutable.Stack(1,2,3) //堆栈，先进后出
Queue mutable/immutable val q=scala.collection.mutable.Queue(1,2,3) //队列，先进先出
BitSet mutable/immutable val bit=scala.collection.mutable.BitSet(3,2,0) //位集合
ListMap immutable val map = scala.collection.immutable.ListMap(1->“one”, 2->“two”)
HashSet mutable val set= scala.collection.mutable.HashSet(1,2,3)
HashMap mutable val stu= scala.collection.mutable.HashMap(“name” -> “Jason”, “age” -> “18”)

①Scala List常用操作

var c=List(‘a’,‘b’,‘c’)
var x=‘x’+:c //List[char]=List(x,a,b,c)
var c = List[Char](‘a’, ‘b’, ‘c’)
var x = ‘x’ +: c // (x, a, b, c)
var y = c :+ ‘x’ // (a, b, c, x)
import scala.collection.mutable._
va lb = ListBuffer[Int](1, 2, 3, 4)
lb += 100 //1, 2, 3, 4, 100
lb += (21, 33)//
88 +=: lb //88, 1, 2, 3, 4, 100, 21, 33
List(77, 66) ++=: lb

var l = List[Int](2, 3, 4, 6, 8, 9, 11, 20)
var x = l grouped 3 //等价l.grouped(3)
x.next() //(2, 3, 4)
x.next() //(6, 8, 9)
var y = l sliding 2
y.next() // (2, 3)
y.next() // (3, 4)

var a1 = Array[Int](1, 2, 3, 4)
var a2 = Array[Int](100, 200, 300, 400)
var a = List.concat(a1, a2)//Array->List
a3=a1++a2 //Arrays->Array
a(3) = 333 //Error
a3(3)=333 //OK
var b = Array(333, “333”, ‘3’, false )
var c = List.concat(a, b)
val x = a.filter( _ %2 != 0 )
val y = a.reverse
var m = a.groupBy(t => t%2 == 0)
var n = a.slice(2, 4)
a.sorted //1, 2, 3, 4, 100, 200, 300, 400
a.sorted( Ordering.Int.reverse )
a.sortWith( _ > _ )
a.sortBy( x => x ) //升序
a.sortBy( x => x*(-1) ) //降序

②Scala Set常用操作

var s = Set(“ab”, “yz”)
s += “mn” //mn, ab, yz
s += “mn” //??
s -= “yz” //mn, ab
var t = Set(“ab”, “gh”, “mn”, “st”, “yz” )
t – s //gh, st, yz
t ++ s //ab, gh, mn, st, ya

var os = SortedSet(1, 99, 66, 54, 77 )
os //1, 54, 66, 77, 99
os += 33
os //1, 33, 54, 66, 7

var s = Set(“ab”, “yz”)
var t = Set(“ab”, “gh”, “mn”, “st”, “yz” )
//求交集
t & s
t intersect s
//求并集
t | s
t union s
//求差集
t &~ s
t diff s

import scala.collection.mutable
SortedSet(10,2,4,8,9) //
scala.collection.mutable.SortedSet[Int]=TreeSet(2,4,8,9,10)

③Scala Map常用操作
var m = Map[String, Int](“a”->1, “b”->2, “c”->3, “d”->4, “e”->5, “f”->6, “g”->7, “h”->8, “i”->9)
m(“a”) //1
m += (“j”->0)
m += (“j”->0) //??
m += (“j”->11) //??
var n = m ++ Map[String, Int](“a”->3, “j”->99) //??
n -= (“g”, “e”)

遍历map
for((k,v)<-m)(println(k+v))
//有序Map，按照key的字母序进行排序
val m2=scala.collection.SortedMap(“dd”->25,“c”->30,“aa”->25,“bb”->29)
//定义一个可变map
val sti=scala.collectiom.mutable.Map(“jack”->20,“tom”->21,“peter”->22)