Scala-数组、集合、元组和文件

本文深入探讨了Scala中各种数据结构的声明与操作,包括数组、映射、集合、元组等,并详细介绍了文件读写及URL读取的方法。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

数组

一、一维数组的声明

var array = new Array[Int](10)
var array : Array[Int] = {}
var array = Array()
import scala.collection.mutable._
var array = ArrayBuffer[Int]()

二、多维数组的声明

var array = Array.ofDim[Int](3,4)
var array = new Array[Array[Int]](10)

映射(Map)

一、可变的Map

import scala.collection.mutable._
var map = Map("Destiny" -> 1,"Freedom" -> 2)
var map = Map(("Destiny",1),("Freedom",2))

二、不可变的Map

import scala.collection.immutable._
var map = Map("Destiny" -> 1,"Freedom" -> 2)
var map = scala.collection.immutable.Map(("Destiny",1),("Freedom",2))

三、Map的操作

//获取Map的Value
map("Freedom")
map.get("Freedom")
map.getOrElse("Freedom",-1)
//判断key是否存在
map.contains("Freedom")
//添加或移除新的元素
map += "Fate" -> 3
map -= "Fate" -> 3 
//更新Map的Value
map("Freedom") = 1
//Map的迭代
map.foreach(println)
for(s <- map)
println(s)

集合(List)

一、不可变的List

var list = List(1,2,3)
var nulList : List[Nothing] = List()
var dim : List[List[Int]] = List(List(1,2,3),List(4,5,6))

//查看第一个元素
list.head
//查看除第一个元素外的元素
list.tail

二、可变的LinkedList

import scala.collection.mutable._
var linkedList = LinkedList(1,2,3)

while(linkedList != Nil){
	//当前元素乘以2
	linkedList.elem = linkedList.elem * 2
	//移动指针到下一个元素
	linkedList = linkedList.next
}
//高阶函数
linkedList.map(_*2)

序列

一、Vector

Vector是一个带下标的序列,可以通过下标来访问Vector中的元素(不可变)

var vector = Vector(1,2,3)

二、Range

Vector是一个整数的序列

Range(0,5)
println(0 until 5)
print(0 to 5)
('0' to '9') ++ ('A' to 'Z')
//转成List
1 to 5 toList

一、Set

不重复元素的集合(不可变)

var s = Set(1,2,3)

二、SortedSet

可排序、可变的

import scala.collection.mutable._
var sortedSet = SortedSet(1,2,3)
//判断元素是否存在
sortedSet.contains(1)
//集运算
var s1 = Set(1,2,3,4,5,6)
var s2 = Set(5,6,7,8,9,10)
//并集
s1 union s2
//交集
s1 interset s2
//补集
s1 diff s2

元组(Tuple)

一、Tuple的声明

var tuple = Tuple3("Destiny","Freedom",1)
var tuple = ("Destiny","Freedom",1)

二、Tuple的操作

//获取某索引的值
tuple._1
//Tuple的迭代
tuple.productIterator.foreach(println)

文件操作

import java.io.{File, FileInputStream, PrintWriter}
import scala.io.Source._
object FileDemo {
  
  def main(args: Array[String]): Unit = {
    var source = fromFile("C:\\Users\\Administrator\\Desktop\\log.txt","GB2312")

    //将文件作为字符串输出
    println(source.mkString)

    //将文件的每一行读入并输出
    var line = source.getLines()
    line.foreach(println)

    //读取字符
    for (s <- source) println(s)

    //读取URL
    var url = fromURL("http://www.baidu.com","UTF-8")
    println(url.mkString)

    //Scala不支持读取二进制文件
    //通过调用java的InputStream来实现
    var file = new File("C:\\Users\\Administrator\\Desktop\\log.txt");
    //实例化FileInputStream
    var in = new FileInputStream(file)
    //创建一个buffer数组
    var buffer = new Array[Byte](file.length().toInt)
    //读取文件
    println(in.read(buffer))
    //关闭流
    in.close()

    //通过java来实现写文件
    var out = new PrintWriter("C:\\Users\\Administrator\\Desktop\\log.txt")
    for (s <- 0 until 10) out.println(s)
    //关闭流
    out.close()
  }
}
### 数组、列表元组的区别与用法 #### 1. 数组 (Array) 数组是一种基本的数据结构,用于存储相同类型的多个元素。以下是关于数组的一些重要特性: - **特点**: 数组中的每个元素都有一个索引,通常从 `0` 开始计数[^2]。在某些编程语言中,数组可以分为定长数组变长数组。定长数组一旦创建后其大小不可更改,而变长数组则允许动态调整大小。 - **定义方式**: - 使用固定长度的方式定义数组: ```scala val arrayFixedLength = new Array[Int](5) // 创建一个长度为5的整型数组 ``` - 使用具体元素来初始化数组: ```scala val arrayWithElements = Array(1, 2, 3, 4, 5) // 初始化带有元素的数组 ``` - **操作方法**: 数组支持多种内置的操作方法,比如遍历 (`forEach`) 映射转换 (`map`) 等功能[^1]。然而需要注意的是,这些方法仅适用于真正的数组对象而非类数组对象。 --- #### 2. 列表 (List) 列表也是一种常见的线性数据结构,在许多高级编程语言中有广泛的应用。它类似于数组但具有更灵活的功能集。 - **特点**: 列表通常是基于链表实现或者作为动态数组存在。它们能够轻松地执行插入删除等复杂操作,并且大多数情况下提供了丰富的迭代器接口以及函数式编程的支持。 - **主要区别于数组的地方在于灵活性**, 即使是在运行期间也可以方便地修改内容而不必担心内存分配问题. - **示例代码**(Scala为例): ```scala val listExample = List(1, 2, 3, 4) // 不可变列表 var mutableList = scala.collection.mutable.ListBuffer() // 可变列表 mutableList += 5 // 向可变列表添加新项 ``` - **优势**: 对于频繁增删场景下的性能表现优于传统意义上的静态数组;另外由于现代框架往往提供大量针对集合类型优化后的算法库所以开发效率也会有所提升。 --- #### 3. 元组 (Tuple) 元组是用来保存不同类型值的一个简单容器形式。尽管它可以看作是一个小型版本的记录(record),但它并不具备像其他两种结构那样强大的扩展能力。 - **特点**: 元组的主要特征之一就在于它的异构性质——即同一个实例内部可能包含完全不同的数据类别组合而成的整体单位。而且不像常规意义上面向对象设计模式下所强调的对象封装概念一样严格区分字段访问权限等问题上显得更加自由随意些。 - **使用案例**: 当我们需要传递少量关联性强却又彼此独立的信息给某个过程调用时非常合适。 ```scala val tupleSample = ("Alice", 30, true) // 创建三元组 println(tupleSample._1) // 输出第一个成员:Alice ``` --- ### 总结对比表格 | 属性/类型 | 数组(Array) | 列表(List) | 元组(Tuple) | |-----------|--------------------------------------|---------------------------------------|-------------------------------------| | 存储 | 多个同种类型 | 支持多态 | 异质 | | 长度 | 固定或变化(取决于实现) | 动态 | 常量 | | 访问速度 | O(1) | 平均O(n)(对于链接版实现而言) | O(1) | | 修改难度 | 较难(特别是定长情况) | 易 | 几乎不可能直接变更 | ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值