Scala 集合

数组

1. 创建数组

new Array[Int](10)

赋值：arr(0) = xxx

Array[String](“s1”,”s2”,”s3”)

2. 数组遍历

 for foreach

3. 创建一维数组和二维数组

4. 数组中方法举例

 Array.concate：合并数组 Array.fill(5)(“zhangsan”)：创建初始值的定长数组

创建两种方式:

/** * 创建数组两种方式： * 1.new Array[String](3) * 2.直接 Array */ //创建类型为 Int 长度为 3 的数组 val arr1 = new Array[Int](3) //创建 String 类型的数组，直接赋值 val arr2 = Array[String]("s100","s200","s300") //赋值 arr1(0) = 100 arr1(1) = 200 arr1(2) = 300

遍历两种方式：

/** * 遍历两种方式 */ for(i <- arr1){ println(i) } arr1.foreach(i => { println(i) }) for(s <- arr2){ println(s) } arr2.foreach { x => println(x) }

创建二维数组:

/** * 创建二维数组和遍历 */ val arr3 = new Array[Array[String]](3) arr3(0)=Array("1","2","3") arr3(1)=Array("4","5","6") arr3(2)=Array("7","8","9") for(i <- 0 until arr3.length){ for(j <- 0 until arr3(i).length){ print(arr3(i)(j)+" ") } println() } var count = 0 for(arr <- arr3 ;i <- arr){ if(count%3 == 0){ println() } print(i+" ") count +=1 } arr3.foreach { arr => { arr.foreach { println } }} val arr4 = Array[Array[Int]](Array(1,2,3),Array(4,5,6)) arr4.foreach { arr => { arr.foreach(i => { println(i) }) }} println("-------") for(arr <- arr4;i <- arr){ println(i) }

数组中的方法:

5. 可变长数组

/** * 可变长度数组的定义 */ val arr = ArrayBuffer[String]("a","b","c") arr.append("hello","scala")//添加多个元素 arr.+=("end")//在最后追加元素 arr.+=:("start")//在开头添加元素 arr.foreach(println)

list

1. 创建 list

val list = List(1,2,3,4)

Nil 长度为 0 的 list

2. list 遍历

foreach ，for

3. list 方法举例

 filter:过滤元素 count:计算符合条件的元素个数 map：对元素操作 flatmap ：压扁扁平,先 map 再 flat //创建 val list = List(1,2,3,4,5) //遍历 list.foreach { x => println(x)} // list.foreach { println} //filter val list1 = list.filter { x => x>3 } list1.foreach { println} //count val value = list1.count { x => x>3 } println(value) //map val nameList = List( "hello zhangsan", "hello xasxt", "hello shsxt" ) val mapResult:List[Array[String]] = nameList.map{ x => x.split("") } mapResult.foreach{println} //flatmap val flatMapResult : List[String] = nameList.flatMap{ x =>x.split(" ") } flatMapResult.foreach { println }

4. list 方法总结

5. 可变长 List

/** * 可变长 list */ val listBuffer: ListBuffer[Int] = ListBuffer[Int](1,2,3,4,5) listBuffer.append(6,7,8,9)//追加元素 listBuffer.+=(10)//在后面追加元素 listBuffer.+=:(100)//在开头加入元素 listBuffer.foreach(println)

set

1. 创建 set

注意：set 集合会自动去重

2. set 遍历

foreach，for

3. set 方法举例

 交集：intersect ,& 差集: diff ,&~ 子集:subsetOf 最大:max 最小:min 转成数组，toList 转成字符串：mkString(“~”)

4. set 方法总结

//创建 val set1 = Set(1,2,3,4,4) val set2 = Set(1,2,5) //遍历 //注意：set 会自动去重 set1.foreach { println} for(s <- set1){ println(s) } println("*******") /** * 方法举例 */ //交集 val set3 = set1.intersect(set2) set3.foreach{println} val set4 = set1.&(set2) set4.foreach{println} println("*******") //差集 set1.diff(set2).foreach { println } set1.&~(set2).foreach { println } //子集 set1.subsetOf(set2) //最大值 println(set1.max) //最小值 println(set1.min) println("****") //转成数组，list set1.toArray.foreach{println} println("****") set1.toList.foreach{println} //mkString println(set1.mkString) println(set1.mkString("\t"))

set 方法总结

5. 可变长 set

/** * 可变长 Set */ import scala.collection.mutable.Set val set = Set[Int](1,2,3,4,5) set.add(100) set.+=(200) set.+=(1,210,300) set.foreach(println)

map

1. map 创建

 Map（1 –>”zhangsan’） Map((1,”zhangsan”))

注意：创建 map 时，相同的 key 被后面的相同的 key 顶替掉，只保留一个。

val map = Map( "1" -> "zhangsan", 2 -> "shsxt", (3,"xasxt") )

2. 获取 map 的值

map.get(“1”).getmap.get(100).getOrElse(“no value”)：如果 map 中没有对应项，赋值为getOrElse 传的值。 //获取值 println(map.get("1").get) val result = map.get(8).getOrElse("no value") println(result)

3. 遍历 map

 for,foreach //map 遍历 for(x <- map){ println("====key:"+x._1+",value:"+x._2) } map.foreach(f => { println("key:"+ f._1+" ,value:"+f._2) })

4. 遍历 key

 map.keys //遍历 key val keyIterable = map.keys keyIterable.foreach { key => { println("key:"+key+", value:"+map.get(key).get) }} println("---------")

5. 遍历 value

map.values //遍历 value val valueIterable = map.values valueIterable.foreach { value => { println("value: "+ value) } }

6. 合并 map

 ++ 例：map1.++(map2) --map1 中加入 map2 ++: 例：map1.++:(map2) –map2 中加入 map1

注意：合并 map 会将 map 中的相同 key 的 value 替换

//合并 map val map1 = Map( (1,"a"), (2,"b"), (3,"c") ) val map2 = Map( (1,"aa"), (2,"bb"), (2,90), (4,22), (4,"dd") ) map1.++:(map2).foreach(println)

7. map 中的方法举例

 filter:过滤，留下符合条件的记录 count:统计符合条件的记录数 contains：map 中是否包含某个 key exist：符合条件的记录存在不存在 /** * map 方法 */ //count val countResult = map.count(p => { p._2.equals("shsxt") }) println(countResult) //filter map.filter(_._2.equals("shsxt")).foreach(println) //contains println(map.contains(2)) //exist println(map.exists(f =>{ f._2.equals("xasxt") }))

Map 方法总结

8. 可变长 map

/** * 可变长 Map */ import scala.collection.mutable.Map val map = Map[String,Int]() map.put("hello",100) map.put("world",200) map.foreach(println)

元组

1. 元组定义

与列表一样，与列表不同的是元组可以包含不同类型的元素。元组的值是通过将单个的值包含在圆括号中构成的。

2. 创建元组与取值

 val tuple = new Tuple（1） 可以使用 new val tuple2 = Tuple（1,2） 可以不使用 new，也可以直接写成 val tuple3 =（1,2,3） 取值用”._XX” 可以获取元组中的值

注意：tuple 最多支持 22 个参数

//创建，最多支持 22 个 val tuple = new Tuple1(1) val tuple2 = Tuple2("zhangsan",2) val tuple3 = Tuple3(1,2,3) val tuple4 = (1,2,3,4) val tuple18 = Tuple18(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18) val tuple22 = new Tuple22(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22) //使用 println(tuple2._1 + "\t"+tuple2._2) val t = Tuple2((1,2),("zhangsan","lisi")) println(t._1._2)

3. 元组的遍历

tuple.productIterator 得到迭代器，进而遍历

//遍历 val tupleIterator = tuple22.productIterator while(tupleIterator.hasNext){ println(tupleIterator.next()) }

4. swap,toString 方法

注意：swap 元素翻转，只针对二元组

/** * 方法 */ //翻转，只针对二元组 println(tuple2.swap) //toString println(tuple3.toString())