Scala语言——(二)

本文深入探讨Scala中的集合,包括可变与不可变集合的区别、数组的定义与使用、元组的创建及遍历、Map的构建、List的操作、高阶函数的应用以及闭包和柯里化的概念。通过对这些核心概念的理解,帮助读者深化对Scala编程的掌握。
摘要由CSDN通过智能技术生成

官方文档 https://docs.scala-lang.org/overviews/collections/overview.html

一、集合

1.可变集合和不可变集合

不可变集合可以安全的并发访问。

可变集合可以在适当的地方被更新或扩展。这意味着你可以修改,添加,移除一个集合的元素。

# 不可变集合
	scala.collection.immutable (Scala默认采用不可变集合)
# 可变集合
	scala.collection.mutable 

不可变集合
在这里插入图片描述
可变集合
在这里插入图片描述

2.数组
Array被隐式转换为WrappedArray(scala.collection.mutable.WrappedArray),间接拥有了集合的特征。
# Array
- 定长数组,数组不可扩容 scala.Array
- 定长数组是可变集合的一种,内容可变,但是其长度不可变
# ArrayBuffer
- 变长数组,数组可扩容 scala.collection.mutable.ArrayBuffer
  1. 定义数组
var arr=new Array[Int](3)
var arr=Array(1,2,3)
  1. 数组的一般用法
object ArrayDemo {
  def main(args: Array[String]){
    //初始化一个长度为8的定长数组
    val arr1 = new Array[Int](8)
    //会有初始化零值:Array[Int] = Array(0,0,0,0,0,0,...)
    //直接打印定长数组,内容为数组的hashcode值
    println(arr1)
    //将数组转换成数组缓冲,就可以看到原数组中的内容了
    //toBuffer会将数组转换长数组缓冲
    println(arr1.toBuffer)

    //注意:如果不使用new获取数组,相当于调用了数组的apply方法,直接为数组赋值
    //通过一组初始化值定义定长数组
    val arr2 = Array[Int](10,20,30)
    //输出数组元素值
    println(arr2.toBuffer)

    //定义一个长度为3的定长数组
    val arr3 = Array("hadoop", "storm", "spark")
    //使用()来访问元素
    println(arr3(2))

    //包含10个整数的数组,初始化值为0 
    val nums = new Array[Int](10)
    //遍历数组
    for(i <- 0 until nums.length)
      print(s"$i:${nums(i)} ")	//s字符串插值
    println()

    //包含10个字符串的数组,初始化值为null
    val strs0 = new Array[String](10)
    for(i <- 0 until strs0.length)
      print(s"$i:${strs0(i)} ")
      println()

    //赋初值的字符串数组
    val strs1 = Array("hello" ,"world")
    for(i <- 0 until strs1.length)
      print(s"$i:${strs1(i)} ")
      println()

    //访问并修改元素值
    strs1(0) = "byebye"
    for(i <- 0 until strs1.length)
      print(s"$i:${strs1(i)} ") 
      println()

  }
}

  1. 数组遍历
//使用增强for循环进行数组遍历   
for(elem <- nums)
	println(elem)
3.元组
1.最多支持22个元素组合,分别对应类型Tuple1~Tuple22,相应也称为一元组(一般不用)、二元组、三元组...
2.元组可以容纳不同类型的元素
3.元组不可变

1.创建并元组

-二元组(map类型)
val tuplle1=("hadop",1)
-三元组
val tuple2 = (1, 3, "Fred")
val tuple3 = new Tuple3(1, 3, "Fred")

-访问元组
// 按照索引访问元组的第一个元素,从0开始
val value1 = tuple3._3

2.元组遍历

for (elem <- tuple1.productIterator) {
  print(elem)
}
println()
3.Map(映射)

在Scala中,把哈希表这种数据结构叫做映射。Scala中的Map存储的内容是键值对(key-value),

Map区分可变Map (scala.collection.mutable.Map) 
不可变Map(scala.collection.immutable.Map) 
不可变的Map(仅TreeMap)支持有序,而可变的Map是无序的。

1.构建映射

("a",1)
"a"->1
4.List
1.列表中的元素类型必须相同。
2.列表是有序的。
3.列表是不可变的,内容及长度都不可变。
4.任何对List的修改操作都会返回新的List,而原List不会变化

1.构建

//可以使用Nil构建一个空列表  Nil=List[Nothing]
val empty = Nil
//也可以使用空元素构建一个空列表
val empty : List[Nothing] = List()

scala> val fruit = List("apples", "oranges", "pears")
fruit: List[String] = List(apples, oranges, pears)

2.遍历

/**
 * List的各种遍历方式
 */
val lst = List(1,2,3,4,5);
print("foreach遍历:")
lst.foreach { x => print(x+",")}  //foreach遍历,这个是传统遍历,新手不熟无奈之下可以用它
println("")

var temp = lst.map { x => x+1 }   //遍历,与foreach的区别是返回值为List【B】
println("map遍历:"+temp.mkString(","));


var temp1 = lst.reduceLeft((sum,i)=>sum +i) //遍历,返回值类型是一个与集合相同的Int
println("reduce遍历返回Int:"+temp1);

var temp2 = lst.foldLeft(List[Int]())((x,y)=>y::x); //遍历,返回值是自定义类型
//ps fold类函数还可以改成 :\ ,/:的形式,代码精简了不少,但是可读性却减低了例如
println("foldLeft遍历返回自定义类型:"+temp2.mkString(","));

var temp3=(   List[Int]() /: lst){(m,c)=>c::m} //遍历,实现反转
println("foldLeft遍历实现反转:"+temp2.mkString(","));

3.常用方法

//与head,tail对应的last init
scala> val abcde = List('a', 'b', 'c', 'd', 'e')
abcde: List[Char] = List(a, b, c, d, e)
scala> abcde.last
res12: Char = e
scala> abcde.init
res13: List[Char] = List(a, b, c, d)

//反转列表
scala> abcde.reverse
res14: List[Char] = List(e, d, c, b, a)

//tail,init的泛化
//提取列表的前n个元素
scala>  abcde take 2
res15: List[Char] = List(a, b)
//丢弃列表的前n个元素
scala>  abcde drop 2
res16: List[Char] = List(c, d, e)
scala> abcde splitAt 2
res17: (List[Char], List[Char]) = (List(a, b),List(c, d, e))
scala> List(abcde take 2, abcde drop 2)
res18: List[List[Char]] = List(List(a, b), List(c, d, e))

//拉链操作
scala> abcde zip List(1,2,3,4,5)
res22: List[(Char, Int)] = List((a,1), (b,2), (c,3), (d,4), (e,5))
4.高阶函数

如果一个函数的传入参数为函数或者返回值是函数,则该函数即为高阶函数。前面提到的集合中大部分函数都属于高阶函数:

- map、flatMap
- filter
- fold、reduce
- forall、foreach
- partition
- groupBy
- sortBy
5.闭包

闭包是一个函数,返回值依赖于声明在函数外部的一个或多个变量。

函数体内可以方法相应作用域内的任何变量。

闭包通常来讲可以简单的认为是可以访问一个函数里面局部变量的另外一个函数。

6.柯里化

Curring函数,指的是,将原来接收两个参数的一个函数,转换为两个函数,第一个函数接收原先的第一个参数,然后返回接收原先第二个参数的第二个函数。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

NoMissU

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值