Scala 快速复习篇

前言

今天复习了Scala，记录复习过程

目录

scala 基础

Scala Hello Word

常量

变量

类型转换

运算符

Scala 进阶

If 语句

readLine标准输入

while 循环

九九乘法表

百钱买百鸡

for循环

Scala 函数

自定义-加法函数

自定义-无返回值函数

Scala 数组

数组声明

数组切片

数组迭代

变长数组

增删改查

Map 键值对

创建

取值

迭代

可变 Map：hashMap

Tuple 元组

创建

取值

Scala 函数进阶

匿名函数

高阶函数

返回类型推断

调用函数返回函数

常见的高阶函数

map

filter

reduce

Scala 面向对象

类的定义与对象创建

类的编译

apply 方法

自定义apply方法

构造方法

模式匹配

匹配字符串

匹配数组

样例类

Main 方法

集合

---

scala 基础

Scala Hello Word

print("Hello Word")
println("Hello Word")
val name = "小明"
println(s"hello ${name}")        指定变量打印

常量

val 变量名 = 变量值

val a = 10

a = 20 报错，a是常量，不可变

变量

var 变量名 = 变量值

var a = 10

a = 20

建议一般声明成常量，可以使程序更稳定

类型转换

val a:Int = 10

a.toString        转String类型
a.toInt           转Int类型
…………

运算符

在Scala中所有的运算符都是方法

scala> 1+2               调用方法的简写
res1: Int = 3

scala> 1.+(2)            调用加方法
res2: Int = 3

1 to 10           生成1 到 10 的列表

Scala 进阶

If 语句

if (1 > 3) 3 else 1                 判断条件，返回一个值
1
if ( 2 > 3) 2 else if (2 > 1) 3 else 1    判断条件，返回一个值
3

readLine标准输入

第一种获取输入方式
var name = readLine("请输入你的名字")        从键盘获取一个值

第二种获取输入的方式
import scala.io.StdIn.readLine
var name = readLine("请输入你的名字")        从键盘获取一个值

while 循环

var num = 1
while(num < 10){
    println(num < 10)
    num += 1            scala中没有 自增自减符
}

九九乘法表

var row = 1
while (row <= 9){
    var col = 1
    while(col <= row){
        print(s"${col} X ${row} = ${col * row}\t")
        col+=1
    }
    println("")
    row += 1
}

百钱买百鸡

var hen=0
while(hen <= 20){
    var cock = 0
    while(cock <= 33){
        var chick = 0
        while( chick <= 100){
            var count = hen + cock + chick
            var money = 5 * hen + 3 * cock + chick / 3
            if(count == 100 && money == 100){
                println(s"hen:$hen,cock:$cock,chick:$chick")
            }
            chick += 3
        }
        cock += 1
    }
    hen += 1
}

for循环

for ( x <- 1 to 5) print(x)    //to 包括 5 

-------------结果-------------
1
2
3
4
5
-----------------------------

for ( x <- 1 until 5) print(x)    //until 不包括 5 

-------------结果-------------
1
2
3
4
5
-----------------------------

Scala 没有直接的black方法，需要导包

import scala.,util.contron.Breaks._
for ( x <- 1 to 5){
    if(x == 5){
    break
    }
    println(x)
}

------------结果-------------
1
2
3
4
----------------------------

for (x <- "hello") println(x)    //迭代字符串

-----------结果-------------
h
e
l
l
o
----------------------------

for (x <- 1 to 3 ; y <- 1 to 3){    //多重for循环
    println(s"$x * $y = ${x * y}")
}

-----------结果--------------
1 * 1 = 1
1 * 2 = 2
1 * 3 = 3
2 * 1 = 2
2 * 2 = 4
2 * 3 = 6
3 * 1 = 3
3 * 2 = 6
3 * 3 = 9
------------------------------


scala 中没有 continue ， 实现continue的方法
方法一
import scala.,util.contron.Breaks._
for ( x <- 1 to 5){
    breakable{
        if(x == 5){
            break
        }
        println(x)
    }
}
---------------结果------------
1
2
3
4
-------------------------------

方法二
    for ( x <- 1 to 5 if (x != 5)){
        println(x)
    }
---------------结果-------------
1
2
3
4
--------------------------------

for(x <- 1 to 10) yield x % 2        将循环的结果返回

Scala 函数

自定义-加法函数

def add(n:Int,m:Int):Int = {      //函数定义
    m + n
}

add(1 , 2)                        //函数调用

3

自定义-无返回值函数

def p(info:String) = println(info)

p("hello world")

------------结果----------
hello world
--------------------------

def p(info:String){println(info)}         省略等号，为无返回值

p("hello world")

------------结果----------
hello world
--------------------------

//参数设置默认值
def deco(a:String="<",b:String,c:Strint=">") = a + b + c

deco(b = "info")

//不定长参数
def add(m:Int*):Int = {    m 是一个数组来接收
    var sum = 0
    for(x <- m){
    sum += x 
    }
}

add( 1 to 100:_*)         将列表展开成一个一个的数字传入过去

Scala 数组

数组声明

val arr = new Array[Int](5)
val arr = Array(1,2,3,4,5)

数组切片

val arr = Array(1 t0 10:_*)

arr.splitAt(3)            //将数组一分为二
--------------------------------------------结果-------------------------------------
res6: (Array[Int], Array[Int]) = (Array(1, 2, 3),Array(4, 5, 6, 7, 8, 9, 10))
-------------------------------------------------------------------------------------

arr.slice(2,5)            //返回数组从2开始到5前面一个元素集合
-----------------------------------------结果----------------------------------------
res7: Array[Int] = Array(3, 4, 5)
-------------------------------------------------------------------------------------

数组迭代

val arr = Array(1 to 10:_*)        //生成一个数组 数组内容 1 到 10 的数字

arr.foreach(parintln)              //迭代

变长数组

导入可变数组的包
import scala.collection.mutable.ArrayBuffer

var arr = ArrayBuffer( 1 t0 4:_*)

增删改查

在尾部添加
arr += 5

在任意位置添加
在第一个位置，添加一个0
arr.insert(1,0)

添加一个集合
arr ++= Array(1,2,3)

删除第一个满足条件的
arr -= 3

删除多个满足条件的
arr --= Array(1,2,2,3)

根据下标删除
删除下标为5的字符
arr.remove(5)

根据下标和偏移量删除
从下标 2 开始删除 3 个
arr.remove(2,3)

根据下标查找元素
返回下标1中的值
arr(1)

通过数据找下标
找第一个匹配成功的数据的下标
arr.indexOf(4)

找第二个匹配成功的数据的下标
arr.indexOf(4,2)

Map 键值对

创建

val mp = Map(1 -> "tom",2 -> "lucy")

取值

根据k取值
mp(1)
------------结果--------------
tom
------------------------------
mp(2)
------------结果--------------
lucy
------------------------------

迭代

mp.keys        取出所有的key
mp.values      取出所有的value

for((k,v) <- mp){        // k,v 一起迭代
    println(k)
    println(v)
}

可变 Map：hashMap

import scala.collection.mutable.HashMap
var mp = HashMap(1 -> "tom" , 2 -> "lucy")

增删改查

添加一个
mp += (3 -> "jack")

删除一个
删出 k 为 1 的 键值对
mp -= 1

改值
mp(2) = "tom"

查询
mp(2)

Tuple 元组

创建

val t1 = ("tom",10)

取值

取第一个值
t1._1

取第二个值
t1._2

取n个值
var(a,b) = t1

map的底层是用元组来组成的

Scala 函数进阶

匿名函数

创建匿名函数 方法一
定义一个函数
def add(n:Int,m:Int) = m + n

用一个变量来应用一个函数
f 是匿名函数
var f = add _

创建匿名函数 方法二
def f = (n:Int,m:int) => m + n

高阶函数

高阶函数就是将一个普通的函数作为一个参数

var f1 = (m:Int,n:Int) => m + n
var f2 = (m:Int,n:Int) => m * n
def call(m:Int,n:Int,f1:(Int,Int) => Int,f2:(Int,Int) => Int{
    if(m > 0) f1(m,n) else f2(m,n)
}

返回类型推断

不省略返回类型
def add(m:Int,n:Int):Int = m + n

省略返回类型（自己推断）
def add(m:Int,n:Int) = m + n

调用函数返回函数

def ff(m:Int) = {
    def f(x:Int) = m * x
    f _                        //只能返回函数的引用，也就是匿名函数
}

def ff(m:Int) = {
    (x:Int) => m * x
}
ff(2)(3)
第一步，第一个参数（2）传给ff函数
第二步,ff函数返回匿名函数 (x:Int) => 2 * x
第三步，第二个参数(3)传给匿名函数
第四步，结果 6

常见的高阶函数

map

var arr = Array(1 to 10:_*)
arr.foreach(println)            //foreach 没有返回值

arr.map((n:Int) => n * 2)       //map 有返回值，迭代每个元素，对每个函数进行处理

arr.map(_ * 2)                  //可以用 _ 来简写

filter

arr.filter((n:Int) => n % 2 == 0)        //filter 过滤操作,保留满足条件的
arr.filterNot((n:Int) => n % 2 == )      //filter 过滤操作，保留不满足条件的

reduce

arr.reduce((n:Int,m:Int) => m + n)

arr.reduce(_ + _)        //聚合操作

第一个下划线：前面两个聚合的结果
第二个下划线：下一个要聚合的参数
累加操作

Scala 面向对象

类的定义与对象创建

class Person{
    private var id = 0       //定义成私有的，不定义默认是公有的,私有的变量不能被外面访问
    def setId(id:Int) = this.id = id    //外面访问不了，可以通过定义set/get方法来访问
    def getId() = id
    var name="tom"
}

类的编译

在命令行输入
scalac scala代码文件
进行编译

apply 方法

var msg = "hello"
for(c <- msg) println(c)

可以通过apply方法，取出字符串中的某个字符

msg.apply(0)        
---------结果-------
h
--------------------
msg(2)                //简写
---------结果-------
l
--------------------

自定义apply方法

class Person2{
    def apply(name:String) = println("hell " + name)
}

var pp = new Person2()
pp.apply("tom")

//apply方法都可以使用极简方法

pp("tom")

构造方法

class Person{
    var id = 0
    var name = "tom"
    def this(name:String)={   //创建构造方法
        this()                //调用默认构造，创建构造方法的时候，这个是不能省略掉的
        this.name=name        
    }
}

模式匹配

匹配字符串

def getNumb(msg:String):Int={
    msg match{
        case "A" => 1
        case "B" => 2
        case "c" => 3
        case _ => 4            //其他的情况
    }
}

匹配数组

var arr = Array(0,1)
var info = arr match{
    case Array(0) => println(0)        //这个数组由0构成的，则进入
    case Array(x,y) => println(x,y)    //这个数组有两个元素构成的，则进入
    case Array(0,_*) => println("_","*") //这个数组由0开头的元素组成
    case Array(0,_*) => println("ANY")    //其他情况
}

样例类

class Dog
case class Jing(name:String) extends Dog
case class Shapi(age:Int) extends Dog

def ma(cl:Any){
    cl match{
        case Jing(name) => println(name)
        case Spapi(age) => println(age)
        case _ => println("ANY")
    }
}

Main 方法

 class 里面是动态方法   object 里面是静态方法  main方法要写在object方法中

集合

List

val arr = Array(1,2,3,4)
var list = list(1,2,3,4)

//head::tail        list由头和尾构成
：：                 相加

Nil                  表示空

 set

不可重复的集合，重复了会自动去重
val set = Set(1,2,3,4,5,1,2,3,4,5)

----------set---------
1,2,3,4,5
----------------------