2.1 数组
import scala.collection.mutable.ArrayBuffer
//scala导包比如导入scala.collection.mutable下所有的类:scala.collection.mutable._
object ArrayDemo {
def main(args: Array[String]): Unit = {
println("======定长数组======")
// 初始化一个长度为8的定长数组，所有元素初始化值为0
var arr1 = new Array[Int](8)
// 底层调用的apply方法
var arr2 = Array[Int](8)
//toBuffer会将数组转换成数组缓冲
println(arr1.toBuffer) // ArrayBuffer(0, 0, 0, 0, 0, 0, 0, 0)
println(arr1(2)) // 使用()来访问元素
println("=======变长数组(数组缓冲)======")
val varr = ArrayBuffer[Int]()
//向数组缓冲尾部追加一个或多个元素(+=)
varr += 1
varr += (2, 3)
//追加一个数组用 ++=
varr ++= Array(4, 5)
varr ++= ArrayBuffer(6, 7)
//指定位置插入元素-1和3；参数1：指定位置索引，参数2：插入的元素可以是多个
// def insert(n: Int, elems: A*) { insertAll(n, elems) }
varr.insert(0,-1,3)
varr.remove(0) //删除指定索引处的元素
//从指定索引处开始删除，删除多个元素；参1：指定索引，参2：删除个数
varr.remove(0,2)
// 从0索引开始删除n个元素
// varr.trimStart(2)
//从最后一个元素开始删除，删除指定个数的元素(length-n max 0)
varr.trimEnd(2)
)
//reduce ==>非并行化集合调用reduceLeft
//(((1+8)+3)+5)...
println(varr.reduce((x,y)=> x+y))
println(varr.reduce(_+_))
println(varr.reduce(_-_))
Array("one","two","three").max //two，字符串比较大小，按照字母表顺序
Array("one","two","three").mkString("-")//以"-"作为数组中元素间的分隔符one-two-three
Array("one","two","three").mkString("1","-","2")//1one-two-three2
//参1：arr元素的数组个数，参2：arr中每个数组中元素个数
val arr = Array.ofDim[Int](2, 3)
arr.head arr.last //数组的第一个和最后一个元素
}
}
yield关键字将原始的数组进行转换会产生一个新的数组，原始的数组不变
def main(args: Array[String]) {
//定义一个数组
val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
//将偶数取出乘以10后再生成一个新的数组
val res = for (e <- arr if e % 2 == 0) yield e * 10
println(res.toBuffer)
//filter过滤接收一个返回值为boolean的函数，过滤掉返回值为false的元素
//map将数组中的每一个元素取出来(_)进行相应操作
val r = arr.filter(_ % 2 == 0).map(_ * 10)
println(r.toBuffer)
//数组元素求和，最大值，排序
println(arr.sum+":"+arr.max+":"+arr.sorted.toBuffer)
}
2.2 映射
在Scala中，把哈希表这种数据结构叫做映射，类似于Java中的Map。
在Scala中，有两种Map：
不可变Map：scala.collection.immutable.Map（可以存储一些配置或参数供多个线程访问，保证线程安全，具体还要结合业务实际场景），内容不可更改
可变Map：scala.collection.mutable.Map==>类似于Java中的HashMap，可以进行put、get、remove等操作，内容可变
map += (“c” -> 3) map += ((“d”,4)) 增加元素 -=移除元素 +/-增加或移除一个元素并返回一个新的集合
注意：通常我们在创建一个集合时会用val这个关键字修饰一个变量，那么就意味着该变量的引用不可变，该引用中的内容是不是可变还取决于这个引用指向的集合的类型
2.3 元组
映射是K/V对偶的集合，对偶是元组的最简单形式，元组可以装着多个不同类型的值，元组是不可变的
zip命令可以将多个值绑定在一起（将两个数组/集合的元素一一对偶）：
注意：如果两个数组的元素个数不一致，拉链操作后生成的数组的长度为较小的那个数组的元素个数
对于元组val t = (1, 3.14, “Fred”)，val (first, second, _) = t // second等于3.14
2.4 集合
Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质。集合分可变（mutable）和不可变（immutable）两种类型，immutable类型的集合初始化后长度和内容都不能改变（注意与val修饰的变量进行区别）
2.4.1 Seq/List
在Scala中列表要么为空（Nil表示空列表）要么是一个head元素加上一个tail列表。
9 :: List(5, 2) :: 操作符是将给定的头和尾创建一个新的列表【注意：:: 操作符是右结合的，如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))】
def main(args: Array[String]): Unit = {
//创建一个不可变集合
val lt = List(1, 2, 3)
/*//添加元素到lt前面生成一个新的List
val lt2 = ("a", -1, 0) :: lt
val lt3 = lt.::(0)
val lt4 = 0 +: lt
val lt5 = lt.+:(0)
println(lt + "==>" + lt2 + "==" + lt3 + "==" + lt4 + "==" + lt5)
val lt6 = lt :+ 4
println("添加元素到后面："+lt6 )*/
//合并两个集合，lt0在lt前面
val lt0 = List(4,5,6,7)
val lt7 = lt0.union(lt)
val lt8 = lt0 ++ lt
println(lt7 +":"+lt8 )
println("lt0在lt后面"+lt ++ lt0)
//将两个集合中的元素一一绑定，如果元素数不一致以较少元素集合为准
println(lt0.zip(lt).toMap)
//将lt0插入到lt前面生成一个新的集合
println(lt0 ++: lt)
println(lt.:::(lt0))
}
def main(args: Array[String]): Unit = {
// 构建一个可变列表，初始有3个元素1,2,3 alt+enter导包
val lst0 = ListBuffer[Int](1,2,3)
//创建一个空的可变列表
val lst1 = new ListBuffer[Int]
//向lst1中追加元素，注意：没有生成新的集合
lst1 += 4
lst1.append(5)
println(lst1)
//将lst1中的元素最近到lst0中， 注意：没有生成新的集合
println(lst0 ++= lst1)
//将lst0和lst1合并成一个新的ListBuffer 注意：生成了一个集合
println(lst0 ++ lst1)
//将元素追加到lst0的后面生成一个新的ListBuffer
val lst3 = lst0 :+ 5
println(lst3)
}
def main(args: Array[String]): Unit = {
// 构建一个可变列表，初始有3个元素1,2,3 alt+enter导包
val lst0 = ListBuffer[Int](1,2,3)
//创建一个空的可变列表
val lst1 = new ListBuffer[Int]
//向lst1中追加元素，注意：没有生成新的集合
lst1 += 4
lst1.append(5)
println(lst1)
//将lst1中的元素最近到lst0中， 注意：没有生成新的集合
println(lst0 ++= lst1)
//将lst0和lst1合并成一个新的ListBuffer 注意：生成了一个集合
println(lst0 ++ lst1)
//将元素追加到lst0的后面生成一个新的ListBuffer
val lst3 = lst0 :+ 5
println(lst3)
}
def main(args: Array[String]): Unit = {
/* //创建一个List
val lst0 = List(1,7,9,8,0,3,5,4,6,2)
//将lst0中每个元素乘以10后生成一个新的集合
val lst1 = lst0.map(_*10)
val lst2 = for(i <- lst0) yield i * 10
println(lst1 + ":" +lst2)
//将lst0中的偶数取出来生成一个新的集合
val lst3 = lst0.filter(_ % 2 == 0)
val lst4 = for(i <- lst0 if(i % 2 == 0)) yield i
println(lst3 + ":" +lst4)
//将lst0排序后生成一个新的集合
val lst5 = lst0.sorted//升序
val lst6 = lst0.sortWith(_>_)//降序
val lst7 = lst0.sortBy(x => x)//升序
println(lst5 + ":" +lst6 + ":" +lst7)
//反转顺序
println(lst5.reverse)
//将lst0中的元素4个一组,类型为Iterator[List[Int]]
val it = lst0.grouped(4)
// println(it.toBuffer)
//将Iterator转换成List
val lst8 = it.toList
//将多个list压扁成一个List
println(lst8.flatten)
//先按空格切分，再压平
val lines = List("hello tom hello jerry", "hello jerry", "hello kitty")
lines.map(_.split(" ")).flatten
lines.flatMap(_.split(" "))//
//并行计算求和
println(lst0.par.sum)
println(lst0.par.reduce(_+_))//非指定顺序
println(lst0.par.reduceLeft(_+_))//指定顺序
//折叠：有初始值（无特定顺序）
val lst11 = lst0.fold(100)((x, y) => x + y)
//折叠：有初始值（有特定顺序）
val lst12 = lst0.foldLeft(100)((x, y) => x + y) */
//聚合
val arr = List(List(1, 2, 3), List(3, 4, 5), List(2), List(0))
// println(arr.flatten.sum)
/*先局部求和，再汇总
_+_.sum：第一个下划线是初始值和后面list.sum和,_.sum是list的和,非并行化时只初始化1次只携带1次
_+_：初始值和list元素和的和 */
val result = arr.aggregate(10)(_+_.sum,_+_)
val res = arr.aggregate(10)((x,y)=>x+y.sum,(a,b)=>a+b)
println(result+":"+res)
val l1 = List(5,6,4,7)
val l2 = List(1,2,3,4)
//求并集
val r1 = l1.union(l2)
//求交集
val r2 = l1.intersect(l2)
//求差集
val r3 = l1.diff(l2)
println(r3)
}
2.4.2 Set
def main(args: Array[String]): Unit = {
//不可变Set
/* val set1 = new HashSet[Int]()
//将元素和set1合并生成一个新的set，原有set不变
val set2 = set1 + 4
//set中元素不能重复
val set3 = set1 ++ Set(5, 6, 7)
val set0 = Set(1,3,5) ++ set3
println(set0)*/
//创建一个可变的HashSet
val set1 = new mutable.HashSet[Int]()
//向HashSet中添加元素
set1 += 2
//add等价于+=
set1.add(4)
set1 ++= Set(1,3,5)
println(set1)
//删除一个元素
set1 -= 5
set1.remove(2)
println(set1)
}
扫一扫
756
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
