Scala编程入门基础随笔

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

简单的函数调用

无参数函数调用

十大函数

1.函数传名调用：在函数内部进行参数表达值的计算。

2.指定函数参数名：指定参数名后，可以不按照顺序传参

3.可变参数：指明最后一个传的参是可重复的，就可以不需要指定函数参数的个数

4.递归：函数自己调用自己

5.默认参数值：有默认参数值的可以不传参也能调用

6. 高阶函数：以其他函数作为参数或者以函数自身为输出结果

7.嵌套函数：函数套函数

8.匿名函数：箭头左面是参数列表，右面是函数体

9.偏应用函数：一种表达式，无需提供函数需要的所有函数，只需要提供部分或者不提供参数

10.函数柯里化：将原来接收两个参数的函数变成接收一个参数的函数。新的函数返回一个以原有第二个参数为参数的函数