Scala集合

1、数组Array

• 包含的元素必须相同
• 直接创建Array[String](“s1”,”s2”,”s3”)
• 创建数组：new Array[Int](10)
• 赋值：arr(0) = xxx
• Array.concate：合并数组
• Array.fill(5)(“appke”)：创建初始值的定长数组
• Any 所有类型的父类型

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

// 创建类型为Int 长度为3的数组
val arr1 = new Array[Int](3)
// 赋值
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  => {
   println("***********")
   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)
}

2、list

• 有序可重复，元素类型可以不同
• val list = List(1,2,3,4)
• Nil长度为 0 的list
• filter:过滤元素
• count:计算符合条件的元素个数
• map：对元素操作，来1个数据出1个数据
• 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
// 来1个String，出1个String
val nameList = List("hello appke", "hello xasxt", "hello scala")
val mapResult:List[Array[String]] = nameList.map(x =>{ x.split(" ") })
mapResult.foreach(println)
// [Ljava.lang.String;@2812cbfa
// [Ljava.lang.String;@2acf57e3
// [Ljava.lang.String;@506e6d5e
// List里面是数组
// result.foreach(arr =>{arr.foreach(println)})

// flatmap 扁平，原来的基础上再压一下
val flatMapResult : List[String] = nameList.flatMap{ x => x.split(" ") }
flatMapResult.foreach(println)

3、set无序不重复

// 创建
val set1 = Set(1,2,3,4,4)
val set2 = Set(1,2,5)
// 注意：set会自动去重
set1.foreach(println)
for(s <- set1) {
   println(s)
}

set方法举例

// 交集
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集合会自动去重
• 交集：intersect ,&
• 差集: diff ,&~
• 子集:subsetOf
• 最大:max
• 最小:min
• 转成数组，toList
• 转成字符串：mkString(“~”)

4、map

• map中每个元素就是一个二元组
• Map(1 –>”bjsxt’）
• Map((1,”bjsxt”))
• 相同的key被后面的相同的key顶替掉，只保留一个
• map.get(“1”).get
• map.get(100).getOrElse("no value")：如果map中没有对应项，赋值为getOrElse默认设置的值

val map = Map(
   "1" -> "appke",
   2 -> "shsxt",
   (3,"xasxt")
)
// 获取值
println(map.get("1").get)
val result = map.get(8).getOrElse("no value")
println(result)


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

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

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

合并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)

map中的方法

• filter：过滤，留下符合条件的记录
• count：统计符合条件的记录数
• contains：map中是否包含某个key
• exist：符合条件的记录存在不存在

// 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")
}))

5、元组：不可变的列表

括号里面一堆元素
取值用”._XX”可以获取元组中的值
没有foreach，直接点出来

// 创建，最多支持22个
val tuple = new Tuple1(1) // 可new可不new
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)


注意：tuple各种类型都支持，最多支持22个参数

元组的遍历：tuple.productIterator得到迭代器，进而遍历

// 遍历
val tupleIterator = tuple22.productIterator
while(tupleIterator.hasNext){
   println(tupleIterator.next())
}
// swap翻转，只针对二元组
println(tuple2.swap)
    
// toString方法
println(tuple3.toString())


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

tuple.productIterator

Scala学习笔记导航

• Scala入门笔记
• Scala类和对象
• Scala函数
• Scala字符串和Trait特征
• Scala集合
• Scala模式匹配
• Scala的Actor模型