Scala常用标准库及函数
数组
一维数组声明与获取
赋值与获取 z(0) z(1)
多维数组
注意:用to循环代表左闭右闭,用until循环代表左闭右开
数组合并
数组中常用的方法
设有一个整形数组nums
indices 返回range
返回一个列表,列表里的内容是(0,1,2,…n-2,n-1,n)
def twoSum(nums: Array[Int], target: Int): Array[Int] = {
for(x<-nums.indices;y<-x + 1 until nums.length){
if(nums(x)+nums(y)==target){
Array(x,y)
}
}
Array(-1,-1);
}
flatMap和filter
def demo():Unit={
var arr = Array(
1,2,3,4,5
)
var tmp1 = arr.filter({
x:Int=>x%2!=0
})//过滤操作
tmp1.flatMap(x=>1 to x)
//将集合的所有元素作为key,然后根据某种运算,计算出来value自动配对
}
+:和:+ 拼接
val k = 0
val a = List(1,2)
val c = k +: a // c中的内容是 (0,1,2)
val d = a :+ k // d中的内容是 (1,2,0)
数组在哪冒号在哪
apply(int index) 根据下标获取元素
字符数组可以用charAt
apply实际上就是取出指定下标的元素
var x = num.apply(index)
clone() 深拷贝
var newnums = nums.clone()
indexOf(int index)查找某个元素的下标
var index = nums.indexOf(x)
lastIndexOf(int index)查找某个元素最后一次出现的下标
var behind = nums.lastIndexOf(target)
combinations(int index)获取所有长度为index的字典序迭代器
def getStr():Unit={
var arr = Array("a","b","c")
var permute = arr.combinations(2)
permute.foreach(x=>println(x))
}
// ab ac bc
permutations获取Array的全排列
以leetcode46为案例
def permute(nums: Array[Int]): List[List[Int]] = {
var list = ListBuffer[List[Int]]()
var permute = nums.permutations
permute.foreach(x=>
list.append(x.toList
))
list.toList
}
sorted sortWith sortBy
case为升序排序,降序只需.reverse
def merge(nums1: Array[Int], m: Int, nums2: Array[Int], n: Int): Unit = {
var num = nums1++nums2
num.sorted
num.sortWith(_<_)
num.sortBy(x=>x)
}
字符串
字符串查找
def strStr(haystack: String, needle: String): Int = {
haystack.indexOf(needle)
}
集合
1.不可变List
元素以线性方式存储,可以存放重复对象,类似于数组,所有元素类型相同,但是就像java的String一样,长度内容都不可变,如果改变,需要创建一个新的List.
常用类库:
其他的一些常用库:
List合并
def main(args: Array[String]): Unit = {
val lst0 = List[Int](4,5,6)
val lst1 = List[Int](1,2,3)
val lst2 = 0 :: lst1 // 0插入到lst1之前,产生一个新的集合
val lst4 = 0 +: lst1 // 0插入到lst1之前,产生一个新的集合
val lst6 = lst1 :+ 3 //3插入到lst1后面,产生一个新的集合
val lst7 = lst1 ++ lst0 //将2个list合并成一个新的List
val lst9 = lst1 ::: lst0 //将2个list合并成一个新的List
val lst10 = List.concat(lst1,lst0) //将2个list合并成一个新的List
}
2.ListBuffer
实际上就是可变长的List。特性其实和List差别不大,但如果使用ListBuffer需要额外引入依赖
append remove
import scala.collection.mutable.ListBuffer
object test {
def main(args: Array[String]): Unit = {
var list1 = ListBuffer[Int]()//在创建的时候也可以赋一个拥有初始参数的列表
var tmpList = List[Int](3)
list1.append(1)//在末尾添加一个1
list1+=(2)//使用+=也可以完成append 的功能
list1 ++= tmpList //使用++=可以完成list的拼接,也可以拼接不可变list
list1 = 1000+:list1//在list1首部添加一个1000
list1 -=(1) //去除list1里面的一个元素
list1.remove(0,1)//去除元素,第一个是下标,第二个是参数的个数
list1.isEmpty//判断集合是否为空
for (l<-list1){
println(l)
}
//output:2 3
}
}
2.Set
集合的对象不按照特定方式排序,并且没有重复对象,默认为不可扩展,但也可以导入mutable变为可扩展。
方法与list类似
3.Map
建立kv链表
一般为不可扩展,但是也可以通过导入mutable变为可扩展
列举一个不可扩展的demo
遍历
get put contains getOrElse update remove swap keys values
再列举一个可扩展的demo
import scala.collection.mutable
object MapDemo {
def main(args: Array[String]): Unit = {
val map1 = new mutable.HashMap[Int, String] //创建可扩展map
map1.put(1, "1") //第一种插入方法
map1 += (2 -> "2") //第二种插入方法
map1 += (3 -> "3") //第三种插入方法
map1(4) = "4" //第四种插入方法
Boolean box = map1.contains(1) //查看当前map是否包含这个key
var v = map1.get(3) //获取key为3的value
var vv = map1(3) //获取key为3的value
var vvv = map1.getOrElse(3, "8") //获取key为3的value,如果为null,就默认返回8
map1.update(3, "300") //修改key为3的value为300
map1 -= 3 //删除一个key
map1 -= (1, 2) //删除多个key
map1.remove(1) //删除一个key
//花式遍历1
for(i<-map1){
println(i)
}
//花式遍历2
for((k,v)<-map1){
println(k+" "+v)
}
//kv交换
for((k,v)<-map1)
yield (v,k)
//kv交换
map1.map(x=>(x._2,x._1))
//kv交换
map1.map(x=>x.swap)
//获取kv的集合
Iterator[Int]= map1.keys
Iterator[String] = map1.values
}
}
4.Tuple
不同类型的集合
5.Option
Option[T]表示有可能包含值的容器,也可能不包含值
6.Array
Scala迭代器
不是集合,是一种访问集合的方法,有两个基本操作:next与hasNext
- next返回迭代器的下一个元素,并且更新迭代器的状态
- hasNext检测是否还有一个元素
迭代器类型为Iterator
简单函数介绍
函数声明格式:
def functionName([参数列表]):[return type]={ 方法体 }
如果函数没有返回值,就返回Unit,类似于void。
HelloWorld.scala
简单的函数调用
无参数函数调用