一、数组
1. 数组有 定长数组:Array
变长数组:ArrayBuffer
不可变的集合或数组一般在immutable包下面,scala默认将这个包导入进来了
;可变的集合或数组一般在mutable包下,需要手动导入
。
Array 是一个不可变长数组,但是数组中角标对应的元素是可变的
import scala.collection.mutable.ArrayBuffer
object Demo1 {
def main(args: Array[String]) {
//初始化一个长度为8的定长数组,其所有的元素为0
val arr1 = new Array[Int](8)
//直接打印定长数组,内容为数组的hashcode值
println(arr1)
// 将数组转化为数组缓冲,就可以看到原数组中的内容
println(arr1.toBuffer)
println(arr1.length)
val arr2 = Array("hadoop", "hive", "spark")
// 下面的这种写法会报错,上述定义定长数组,本质上通过伴生对象的apply()实现初始化
// val ARR3 = new Array("hadoop","hive","spark")
println(arr2.toBuffer)
println(arr2(0))
//变长数组
val ab = ArrayBuffer[Int]()
//向数组缓冲的尾部追加一个元素
ab += 1
//追加多个元素
ab +=(2, 3, 4)
//追加一个数组 ++=
ab ++= Array(6, 7)
//追加一个数组缓冲
ab ++= ArrayBuffer(8, 9)
println(ab)
}
}
2.遍历数组
object ForArrayDemo {
def main(args: Array[String]) {
//使用for循环遍历
val arr1 = Array("jack", "tom", "rose")
for (i <- arr1) println(i)
//使用until遍历,与java里面的for(int i; i < arr.length; i ++)类似
val arr2 = Array("scala", "spark", "hadoop")
for (i <- (0 until (arr2.length)))
println(i + "---" + arr2(i))
//反转数组
for (i <- (0 until arr2.length).reverse)
println(i + "---" + arr2(i))
}
println(arr1.max)
println(arr1.min)
println(arr1.sum)
println(arr1.head) //取第一个元素
println(arr1.last) //取最后一个元素
arr1.update(0, 0) //更新指定角标的元素的值
}
}
3.数组转换
object TransDemo {
def main(args: Array[String]) {
val arr1 = Array(1,2,3,4,5)
//yield 把每一个元素遍历后,处理放到一个新的区间里面去
val arr2 = for(i <-arr1 if i % 2 == 0)yield i * 10
println(arr2.toBuffer)
//map 是把原来数组的每一个元素拿出来(自己完成遍历操作),然后处理了得到一个新的数组
println(arr1.map(_*100).toBuffer)
//filter 是对元素进行筛选(自己内部加了if条件),然后放入一个新的数组中
val arr3 =arr1.filter(_%2==0).map(_+100)
println(arr3.toBuffer)
}
}
二、映射
scala中把映射
scala中把hash表这种数据结构叫映射
构建映射有两种方式,一种是箭头 ->,一种是元组()
object MapDemo {
def main(args: Array[String]) {
/*注意:在Scala中,有两种Map,一个是immutable包下的Map,
该Map中的内容不可变;另一个是mutable包下的Map,该Map中的内容可变*/
//不可变
val scor = Map(("tommy",80),("jackky",90),("rosey",100))
//可变
val scores = scala.collection.mutable.Map(("tom",80),("jack",90),("rose",100))
println(scores("tom"))
scores("tom") = 88
println(scores("tom"))
//可以先对key进行判断,如果存在则取出对应的value
if(scores.contains("tom")){
println(scores("tom"))
}
//get 方法返回的是一个Option对象,这个对象有两个小弟:Some和None
//如果有值则返回的是some,否则返回的是None
//通过Option的get方法可以取出Some里面的值
val maybeInt: Option[Int] = scores.get("tom")
println(maybeInt.get)
scores += (("kobe",100),("zms" , 99),("kuli",1))
println(scores("kobe"))
//用getOrElse ,如果取不到,可以返回一个给定的默认值
val star = scores.getOrElse("韦德","闪电侠")
val star1 = scores.getOrElse("kobe",0)
println(star) //闪电侠
println(star1) //100
}
}
三、元组
映射是K/V对偶的集合,对偶是元组最简单的形式,元组可以封装多个不同类型的值,注意元组的角标是从1 开始的。
object TupleDemo {
def main(args: Array[String]) {
val tuple2: (Int, String) = (3, "value")
val tuple3 = ("hi", "heiio", "baibai")
val tuple, (key, value) = ("key", "value")
println(tuple2._2)
val t1 = Array(1,2)
val t2 = Array("hah","ok")
//拉链操作,zip命令可以将多个值绑定在一起
val t3 : Array[(Any,Any)] = t1.zip(t2)
t3.foreach(x => println(x))//(1,hah) (2,ok)
}
}
四、集合
Scala的集合有三大类:序列Seq、集Set、映射Map,所有的集合都扩展自Iterable特质
在Scala中集合有可变(mutable)和不可变(immutable)两种类型,immutable类型的集合初始化后)不能改变不(注意与val修饰的变量进行区别)
1. 不可变的序列 import scala.collection.immutable._
在Scala中列表要么为空(Nil表示空列表)要么是一个head元素加上一个tail列表。
9 :: List(5, 2) :: 操作符是将给定的头和尾创建一个新的列表
注意::: 操作符是右结合的,如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))
def main(args: Array[String]): Unit = {
val list = List(1, 2, 3)
//原来的list是不变的
val newList = list ++ List("dfasd", true)
//println(newList)
/**
* 给头部添加
*/
val newList2 = list.::(4, 5)
val newList3 = list.+:(4, 5)
val newList4 = (4, 5) :: list
val newList5 = (4, 5) +: list
println(newList5)
/**
* 给尾部添加
*/
val newList6 = list.:+(4, 5)
val newList7 = list ++ List(4, 5)
val newList8 = list ++: List(4, 5)
// println(newList8)
/**
* list 的常规操作
*/
println(list.sum)
println(list.max)
println(list.min)
println(list.head)
println(list.last)
list.updated(0, 0)
list.reverse
list.mkString(",")
list.mkString("[", ",", "]")
/**
* list 的转换操作
*/
list.map(x=>x).reverse.sortBy(x=>x).filter(x=>true).foreach(println(_))
}
2.
def main(args: Array[String]) {
//创建了一个lst0 有初始值
val lst0 = ListBuffer[Int](1,2,3)
//创建空的lst1
val lst1 = new ListBuffer[Int]
println("lst1:"+ lst1)
//改lst1 添加一个元素,从打印结果可以看出,添加元素的两种方式: append 与 +=
lst1.append(4)
lst1 += 5
println("lst1:"+ lst1)
//将lst1 里面的元素追加到lst0
lst0 ++=lst1
println("lst0:" + lst0)
// 注意:下面的情况会产生一个新的集合
val lst3 = lst0 ++ lst1
val lst4 = lst1 :+ 10
println("lst3:" + lst3)
println("lst4:" + lst4)
}
}
3.Set
def main(args: Array[String]): Unit = {
/**
* 不可变的
*/
val set0 = Set(1, 2, 3, 4)
val set1 = set0 + 9
val set2 = set0 ++ Set(5, 6, 7)
set0.foreach(println(_))
/**
* 可变的
*/
val set3 = collection.mutable.Set(1, 2, 3, 4, 5)
set3 += 5
set3 ++= Set(6, 7, 8, 9)
println(set3)
}