网站设计哪家便宜,seo网站推广推荐,乡土文化网站怎么做,怎样建外贸网站Scala的集合操作之#xff0c;可变数组和不可变数组#xff0c;可变List集合与不可变List集合
不可变数组
/*
traversable/ˈtrvəsəbl/adj.能越过的#xff1b;可否认的*/
object Test01_ImmutableArray {def main(args: Array[String]): Unit {// 1. 创建数组val arr:…Scala的集合操作之可变数组和不可变数组可变List集合与不可变List集合
不可变数组
/*
traversable/ˈtrævəsəbl/adj.能越过的可否认的*/
object Test01_ImmutableArray {def main(args: Array[String]): Unit {// 1. 创建数组val arr: Array[Int] new Array[Int](5)// 另一种创建方式/*Array.apply(12, 37, 42, 58, 97)通过Array伴生对象的apply方法获取一个数组对象apply方法可以省略。等价于Array(12, 37, 42, 58, 97)*/val arr2 Array(12, 37, 42, 58, 97)println(arr)// 2. 访问元素println(arr(0))println(arr(1))println(arr(4))
// println(arr(5))arr(0) 12arr(4) 57println(arr(0))println(arr(1))println(arr(4))println()// 3. 数组的遍历// 1) 普通for循环
// for (i - 0 to arr.length-1) println(arr(i))for (i - 0 until arr.length){println(arr(i))}/*源码注释Produces the range of all indices of this sequence.return a Range value from 0 to one less than the length of this $coll.indices方法实际上还是返回Range伴生对象的until方法def indices: Range 0 until length*/for (i - arr.indices) println(arr(i))println(---------------------)// 2) 直接遍历所有元素增强for循环for (elem - arr2) println(elem)println(---------------------)// 3) 迭代器val iter arr2.iteratorwhile (iter.hasNext)println(iter.next())println(---------------------)// 4) 调用foreach方法arr2.foreach( (elem: Int) println(elem) )// 下面这个foreach遍历跟上面的等价arr.foreach( println )println(arr2.mkString(--))println()// 4. 添加元素val newArr arr2.:(73)println(arr2.mkString(--))println(newArr.mkString(--))val newArr2 newArr.:(30)println(newArr2.mkString(--))val newArr3 newArr2 : 15val newArr4 19 : 29 : newArr3 : 26 : 73println(newArr4.mkString(, ))}
}
可变数组ArrayBuffer
/*** with: 和...在一起具有支持的含义* 一个类继承一个特质用extends,多个特质用extends ..with..* class 类名 extends 特质 1 with 特质 2 with 特质 3...*/
object Test02_ArrayBuffer {def main(args: Array[String]): Unit {// 1. 创建可变数组val arr1: ArrayBuffer[Int] new ArrayBuffer[Int]()val arr2 ArrayBuffer(23, 57, 92)println(arr1)println(arr2)// 2. 访问元素
// println(arr1(0)) // errorprintln(arr2(1))arr2(1) 39println(arr2(1))println()// 3. 添加元素:操作会返回一个新的数组对象操作返回的是原数组自身对象val newArr1 arr1 : 15println(arr1)println(newArr1)println(arr1 newArr1)//可变数组推荐使用操作val newArr2 arr1 19println(arr1)println(newArr2)println(arr1 newArr2)newArr2 13println(arr1)77 : arr1println(arr1)println(newArr2)println()/*append(元素)向数组末尾添加一个元素prepend(元素)向数组头部添加一个元素insert(元素1,元素2)向数组插入多个元素insertAll(2, newArr)向数组2索引位置开始插入一个新的数组prependAll(newArr)向数组头部插入一个新的数组*/arr1.append(36)arr1.prepend(11, 76)arr1.insert(1, 13, 59)println(arr1)arr1.insertAll(2, newArr1)arr1.prependAll(newArr2)println(************************)println(arr1: arr1)/*** 删除操作* remove(n: Int, count: Int)方法从数组n索引位置开始删除count个元素* remove(n: Int)删除数组n索引位置的数据*/// 4. 删除元素arr1.remove(3)println(arr1)arr1.remove(0, 10)println(arr1)//调用 -方法删除某个元素arr1 - 13println(arr1)// 5. 可变数组转换为不可变数组val arr: ArrayBuffer[Int] ArrayBuffer(23, 56, 98)val newArr: Array[Int] arr.toArrayprintln(newArr.mkString(, ))println(arr)// 6. 不可变数组转换为可变数组val buffer: mutable.Buffer[Int] newArr.toBufferprintln(buffer)println(newArr)}
}
多维数组
object Test03_MulArray {def main(args: Array[String]): Unit {// 1. 创建二维数组val array: Array[Array[Int]] Array.ofDim[Int](2, 3)// 2. 访问元素array(0)(2) 19array(1)(0) 25println(array.mkString(, ))for (i - 0 until array.length; j - 0 until array(i).length){println(array(i)(j))}for (i - array.indices; j - array(i).indices){print(array(i)(j) \t)if (j array(i).length - 1) println()}array.foreach(line line.foreach(println))array.foreach(_.foreach(println))}
}不可变List集合
/** List底层源码Scala在List包对象中对List类型进行了重定义type List[A] scala.collection.immutable.List[A]* 我们可以看到这里的List实际上就是来自不可变集合包下的List.* List是一个抽象类sealed abstract class List[A]无法直接New对象它继承了AbstractSeq特质具有LinearSeq[A]等特质* 与List抽象类对应的有一个同名的伴生对象List,我们可以调用伴生对象的apply方法创建List[T] 集合*/
object Test04_List {def main(args: Array[String]): Unit {// 1. 创建一个List不可变的List//val list1 List.apply(23, 65, 87)因为apply方法调用可以简化直接写成List(元素1,元素2,...)val list1 List(23, 65, 87)println(list1)// 2. 访问和遍历元素println(list1(1))
// list没有索引list1.foreach(println)/*3. 添加元素: 向list集合前面头部添加元素: 向list集合尾部添加元素*/val list2 10 : list1val list3 list1 : 23println(list1: list1)println(list2: list2)println(list3: list3)println()/*** 双冒号的功能* ::是Lits集合自带的方法用于为集合添加一个元素,直接添加到集合的头部* 例如list2.::(51)在list2集合前面添加一个51的元素* Nil.::(13)也可以为一个空的list集合添加一个元素*/val list4 list2.::(51)println(list4: list4)val list5 Nil.::(13)println(list5: list5)val list6 73 :: 32 :: Nil// Nil空list集合对象可以链式调用双冒号方法从右向左依次去添加元素val list7 17 :: 28 :: 59 :: 16 :: Nilprintln(list7: list7)// 4. 合并列表val list8 list6 :: list7println(list8: list8)/*** 三冒号和 操作* ::: 与 都能实现将一个list集合所有元素加入另外一个list集合中*/val list9 list6 ::: list7println(list9: list9)val list10 list6 list7println(list10: list10)}
}
可变List集合ListBuffer操作
object Test05_ListBuffer {def main(args: Array[String]): Unit {// 1. 创建可变列表val list1: ListBuffer[Int] new ListBuffer[Int]()val list2 ListBuffer(12, 53, 75)println(list1 list1)println(list2 list2)println()// 2. 添加元素list1.append(15, 62)list2.prepend(20)list1.insert(1, 19, 22)println(list1 list1 )println(list2 list2)println()/*** :带冒号的操作是从右向左向头部添加元素* 不带冒号的操作方法是默认加到list集合后边**/31 : 96 : list1 25 11println(list1 list1)println()// 3. 合并list,操作方法是克隆原来的集合在复制的集合上进行操作。合并后返回一个新的集合val list3 list1 list2println(list1 list1)println(list2 list2)println()// 会直接覆盖原来的集合list1 : list2println(list1 list1)println(list2 list2)println()// 4. 修改元素把索引位置为3的元素修改为30list2(3) 30 //它底层调用了update方法list2.update(0, 89)println(list2 list2)// 5. 删除元素指定某个索引位置的元素也可以使用-操作方法list2.remove(2)list2 - 25println(list2 list2)}
}不可变Set集合操作
object Test06_ImmutableSet {def main(args: Array[String]): Unit {// 1. 创建set,使用Set的伴生对象创建Set集合set集合无序因此会去重val set1 Set(13, 23, 53, 12, 13, 23, 78)println(set1)println()// 2. 添加元素//val set2 set1.(129)跟下面的等价val set2 set1 129println(set1)println(set2)println()// 3. 合并两个set集合使用操作方法会返回一个新的set的集合val set3 Set(19, 13, 23, 53, 67, 99)val set4 set2 set3println(set2)println(set3)println(set4)// 4. 删除元素使用-val set5 set3 - 13println(set3)println(set5)}
}可变Set集合mutable.Set操作
object Test07_MutableSet {def main(args: Array[String]): Unit {// 1. 创建setval set1: mutable.Set[Int] mutable.Set(13, 23, 53, 12, 13, 23, 78)println(set1 set1)println()// 2. 添加元素val set2 set1 11println(set1 set1)println(set2 set2)set1 11println(set1 set1)val flag1 set1.add(10)println(flag1 flag1)println(set1 set1)val flag2 set1.add(10)println(flag2 flag2)println(set1 set1)println()// 3. 删除元素set1 - 11println(set1)val flag3 set1.remove(10)println(flag3 flag3)println(set1 set1)val flag4 set1.remove(10)println(flag4 flag4)println(set1 set1)println()// 4. 合并两个Setval set3 mutable.Set(11,22,33)println(set1: set1 )println(set3 set3 )println(******************)// 合并set1集合与set3集合,返回合并后的新的集合val set4 set1 set3// println(set4: set4 )//set3 set1就会把set1集合的元素合并到set3里面set3 set1 //set3调用 方法, 谁调用谁改变println(set1: set1)println(set3 set3)}
}
Scala集合操作之可变Map 集合和不可变Map集合,元组数据操作
不可变Map集合
object Test08_ImmutableMap {def main(args: Array[String]): Unit {// 1. 创建mapval map1: Map[String, Int] Map(a - 13, b - 25, hello - 3)println(map1)println(map1.getClass)println()// 2. 遍历元素map1.foreach(println)map1.foreach( (kv: (String, Int)) println(kv) )println()// 3. 取map中所有的key 或者 value// keys是包含所有key的Iterable[K]集合// 也可以获取所有map集合的所有key的keySet集合然后遍历keySet集合获取所有key在根据key获取value值for (key - map1.keys){println(s$key --- ${map1.get(key)})}// 4. 访问某一个key的valueprintln(a: map1.get(a).get)/*** map1.get(a)获取的是一个Option[A] 类型,但Option是一个密封的抽象类对应有两个实现一个为None: 如果根据key获取不到值返回的就是一个空集合对象对应的就是 Nonecase object None extends Option[Nothing] {def isEmpty truedef get throw new NoSuchElementException(None.get)}另外一个为Some: 如果根据key获得值了返回的就是 Somefinal case class Some[A](deprecatedName(x, 2.12.0) value: A) extends Option[A] {def isEmpty falsedef get valuedeprecated(Use .value instead., 2.12.0) def x: A value}* map1集合里面没有key为c的键值对如果去获取value值就会报空指针异常* 为了避免报异常可以调用 getOrElse(c, 0)这个方法含义是如果对应的键值对存在则返回不存在默认返回0*/println(c: map1.get(c))println(c: map1.getOrElse(c, 0))//map1.put() 不可变Map是不能往里面添加元素的println(map1(a))}
}
可变Map操作
object Test09_MutableMap {def main(args: Array[String]): Unit {// 1. 创建mapval map1: mutable.Map[String, Int] mutable.Map(a - 13, b - 25, hello - 3)println(map1)println(map1.getClass)println()// 2. 添加元素map1.put(c, 5)map1.put(d, 9)println(map1)/** 使用符号添加数据方法底层调用的是update方法* def update(key: K, value: V) { this ((key, value)) } * 后面跟了一个k-v键值对的二元组因此可以使用这种方式添加元素*/map1 ((e, 7)) //(e, 7)这个一个key-vale的二元组println(map1)println()// 3. 删除元素println(map1(c))map1.remove(c)println(map1.getOrElse(c, 0))map1 - dprintln(map1)println()// 4. 修改元素map1.update(c, 5)map1.update(e, 10)println(map1)println()// 5. 合并两个Mapval map2: Map[String, Int] Map(aaa - 11, b - 29, hello - 5)// 符号操作为 // 把map2中的所有键值对元素添加到map1中map1 map2println(map1)println(map2)println(---------------------------)val map3: Map[String, Int] map2 map1println(map1)println(map2)println(map3)}
}
元组操作
object Test10_Tuple {def main(args: Array[String]): Unit {// 1. 创建元组val tuple: (String, Int, Char, Boolean) (hello, 100, a, true)println(tuple)// 2. 访问数据println(tuple._1)println(tuple._2)println(tuple._3)println(tuple._4)println(tuple.productElement(1))println()// 3. 遍历元组数据for (elem - tuple.productIterator)println(elem)// 4. 嵌套元组val mulTuple (12, 0.3, hello, (23, scala), 29)println(mulTuple._4._2)}
} for推导式和yield关键字
for推导式的用法
Scala中的for推导式是一种用于对集合进行迭代和转换的强大工具。它提供了一种简洁的语法来处理集合中的元素并生成新的集合或执行特定的操作。
for推导式的基本语法如下
for (pattern - collection) {// 循环体
}其中pattern是一个模式用于解构集合中的元素collection是要遍历的集合。
以下是几种常见的for推导式的用法
遍历集合并执行操作
val numbers List(1, 2, 3, 4, 5)
for (num - numbers) {println(num)
}上述示例中for推导式遍历numbers列表中的每个元素并将其打印出来。
过滤并转换集合元素
val numbers List(1, 2, 3, 4, 5)
val evenSquares for (num - numbers if num % 2 0) yield num * num
println(evenSquares)上述示例中for推导式通过添加if条件来过滤出偶数然后将符合条件的偶数平方存储在evenSquares列表中。
多个集合的交叉操作
val colors List(red, green, blue)
val sizes List(small, medium, large)
val combinations for {color - colorssize - sizes
} yield (color, size)
println(combinations)上述示例中for推导式嵌套遍历colors和sizes列表并生成颜色和尺寸的所有可能组合。
除了基本语法之外for推导式还可以使用模式匹配、嵌套条件、变量绑定等更高级的特性。您可以根据具体的需求来灵活使用和组合这些特性以实现更复杂的逻辑。
需要注意的是for推导式在编译时会被转换为其他高阶函数如map、filter、flatMap等因此它具有与使用高阶函数相似的性能特性和灵活性。
yield的使用
在Scala中yield是一个关键字用于生成集合或其他类型的值。它通常用于for循环中以遍历集合元素并执行某些操作。以下是yield关键字的主要用法
在for循环中生成新的集合
val numbers List(1, 2, 3, 4, 5)
val squares for (number - numbers) yield number * number
println(squares) // 输出: List(1, 4, 9, 16, 25)上述示例中yield关键字用于在for循环中生成新的集合squares这个新的集合的元素是通过对原始集合numbers的每个元素进行平方运算得到的。
与模式匹配一起使用
case class Person(name: String, age: Int)val people List(Person(Alice, 25), Person(Bob, 30), Person(Charlie, 35))
val names for (Person(name, _) - people) yield name
println(names) // 输出: List(Alice, Bob, Charlie)上述示例中yield关键字用于提取people列表中每个Person对象的name属性并生成一个新的列表names。
用于表达式求值
val result (for (i - 1 to 10) yield i * i).sum
println(result) // 输出: 385在上述示例中yield关键字用于生成一个包含1到10的数值的集合并对每个元素求平方。随后调用sum方法对所有元素进行求和并返回结果。
需要注意的是在Scala中yield关键字只会将新的集合或值返回给程序的其他部分它不会修改原始的集合或任何其他的状态。此外yield关键字只能用于带有for循环的语句中且只有仅包含一个表达式的for循环才能使用yield生成结果。
