其他分享
首页 > 其他分享> > 一、Scala简明笔记

一、Scala简明笔记

作者：互联网

目录

1、项目创建和环境配置

  1. new project

  2. 确定项目所属组及名称，以及存放目录

  3. 创建scala目录

  4. 将scala目录设置为Sources Root

  5. 添加scala支持

2、Hello world

package chapter01

/*
*  object : 关键字，申明一个单例对象（伴生对象）
*/
object HelloWorld {
	/*
		main 方法：从外部可以直接调用执行的方法
		
		语法：
			def 方法名称(参数名称:参数类型):返回值类型={方法体}
	*/
    def main(s: Array[String]): Unit = {
        println("hello world!")
        System.out.println("hello world! This is from java.")
    }
}

3、变量和数据类型

3.1 注释

scala的注释，同java

  1. 单行注释

    //

  2. 多行注释

    /*
*/

  3. 文档注释

    /**
*
*/

3.3 代码规范

  1. 使用tab键实现缩进，默认整体向右边移动，用shift+tab整体向左移动
  2. 使用ctrl+alt+L来实现格式化代码，让代码美观
  3. 运算符两边习惯性各加一个空格
  4. 一行最长不超过80个字符

3.4 变量和常量

3.5 标识符

Scala 对各种变量、方法、函数等命名时使用的字符序列称为标识符

3.6 字符串

3.7 键盘输入及文件读取

3.8 数据类型

3.9 整数类型

3.10 浮点类型

3.11 字符类型

3.12 布尔类型

3.13 空类型

3.14 类型转换

4、运算符

5、流程控制

5.1 if-else if-else

5.2 For

object Test {
    def main(args: Array[String]): Unit = {

        for (i <- 0 to 9){  // 范围遍历 ，前后闭合的范围
      //类似于 for(i <- 0.to(9))
            println(i+". hello world!")
        }

    }
}


object Test {
    def main(args: Array[String]): Unit = {

        for (i <- 0 until 9){  //不包含边界的范围遍历 ，前闭合后开的范围
      //类似于 for(i <- 0.to(9))
            println(i+". hello world!")
        }

    }
}

object Test {
    def main(args: Array[String]): Unit = {

        for (i <- 0 to 9 if i != 5){
            /* 循环守卫
               循环守卫，即循环保护式（也称条件判断式，守卫）。保护式为 true 则进入循环体内部，为 false 则跳过，类似于 continue。
            * */
            println(i+". hello world!")
        }

    }
}



object Test {
    def main(args: Array[String]): Unit = {

        for (i <- 0 to 9 by 2){
            /* 循环步长
            * */
            println(i+". hello world!")
        }

        for(i <- 9 to 1 by -1){
            println(i)
        }

        for(i <- 1 to 9 reverse){
            println(i)
        }

    }
}


object Test {
    def main(args: Array[String]): Unit = { 
        for(i <- 1 to 3; j <- 1 to 5){
            /* 嵌套for循环
            **/
            println("i="+i+";"+"j="+j)
        }
    }
}


object Test {
    def main(args: Array[String]): Unit = {
        /* 循环返回值
            说明：将遍历过程中处理的结果返回到一个新 Vector 集合中，使用 yield 关键字。
        * */
        val result: immutable.IndexedSeq[Int] = for (i <- 1 to 10) yield {
            i
        }
        print(result)
    }
}

5.3 while/do...while

5.4 循环中断

6、函数式编程

6.1 函数基础

6.1.1 函数基本语法

6.1.2 函数和方法的区别

6.1.3 函数的定义

6.1.4 函数参数

6.1.5 函数至简原则

6.2 函数高级

6.2.1 匿名函数

6.2.2 高阶函数

6.2.3 函数柯里化&闭包

6.2.3 递归

6.2.4 控制抽象

6.2.5 惰性加载

7、 面向对象

7.1 scala包

7.2 类和对象

7.2.1 类定义

7.2.2 属性

7.3 封装

7.3.1 访问权限

7.3.2 方法

7.3.3 对象的创建

7.3.4 构造器

7.4 继承和多态

7.5 抽象类

7.6 伴生对象（单例对象）

​ scala是完全面向对象的语言，为了能够和java语言交互（java中有静态概念，scala中没有静态概念）,产生了一种特殊的对象来模拟类对象，该对象称为单例对象。当单例对象与类名一致时，称该单例对象为这个类的伴生对象，这个类的所有“静态”内容都可以放置在它的伴生对象中声明。

7.7 特质

7.8 类型检测和转换

7.9 Type定义新类型

8 集合

  1. Scala的集合共有三大类：序列Seq、集Set、映射Map，这些集合都扩展自Iterable
  2. 对于几乎所有的集合类，Scala都同时提供了可变和不可变两种版本，所属的包为以下两种：
    • 不可变集合：scala.collection.immutable
    • 可变集合：scala.collection.mutable
  3. scala不可变集合指该集合对象不可修改，每次修改就会返回一个新对象，其不会对原对象进行修改，类比于java中的String对象
  4. scala可变集合指可以直接对原对象进行修改，而不会返回新的对象，类比于java中的StringBuilder对象

8.1 数组

8.1.1 不可变数组

8.1.2 可变数组

8.1.3 不可变数组与可变数组的转换

8.1.4 多维数组

8.2 列表List

8.2.1 不可变List


object Test {
    def main(args: Array[String]): Unit = {
        // 1.创建一个List
        val list1 = List(1,2,3,4)  // List通过伴生对象创建
        println(list1)
        // 2.访问和遍历数组
        println(list1(1))
        list1.foreach(println)
        println("*"*20)

        // 3.添加元素
        val list2 = list1.+:(10)  // 在头部添加元素
        val list3 = 10 +: list1
        println(list2)
        println(list3)
        println("*"*20)
        val list4 = list1.:+(11) // 在尾部添加元素
        val list5 = list1 :+ 11
        println(list4)
        println(list5)

        val list6 = list1.::(51)  // 通过 :: 方法在头部添加元素
        println(list6)
        val list7 = Nil.::(66)  // 通过Nil快速创建列表
        println(list7)

        val list8 = 1 :: 2 :: 3 :: Nil // 由右到左创建列表
        println(list8)

        // 3 合并两个列表
        println("*"*20)
        val list9 = list4 :: list5
        println(list4)
        println(list5)
        println(list9)

        println("*"*20)
        val list10 = list4 ::: list5  // 通过 ::: 方法在头部添加元素,且将列表扁平化处理，得到一个新的列表
        val list11 = list4 ++ list5 // ::: 等同于 ++
        println(list10)
        println(list11)


    }
}

8.2.2 可变List

import scala.collection.mutable.ListBuffer

object Test {
    def main(args: Array[String]): Unit = {
        val list1 = new ListBuffer[Int]()
        val list2 = ListBuffer(1,2,3)
        println(list1)
        println(list2)
    }
}

8.3 集合

8.3.1 不可变Set

object Test {
    def main(args: Array[String]): Unit = {
        // 1.创建set
        val set1 = Set(1, 2, 3, 4, 4, 5, 2, 3)
        println(set1)

        // 2.添加元素
        val set2 = set1.+(20) // 集合在内是无序的,且唯一
        val set3 = set1 + 20
        println(set2)
        println(set3)

        // 3.合并集合
        val set4 = Set(1,2,4,4,5,6,7,8)
        val set5 = set3 ++ set4
        println(set5)

        // 4 删除元素
        val set6 = set5 - 1
        println(set6)
    }
}

8.3.2 可变Set

import scala.collection.mutable

object Test {
    def main(args: Array[String]): Unit = {
        // 1.创建set
        val set1 = mutable.Set(1, 2, 3, 4, 4, 5, 2, 3)
        println(set1)
        println("*"*20)

        // 2.添加元素
        val set2 = set1  + 6
        println(set1)
        println(set2)

        println("*"*20)
        set1 += 33
        println(set1)

        println("*"*20)
        set1.add(44)
        println(set1)

        // 3 删除元素
        println("*"*20)
        set1 -= 2
        println(set1)

        println("*"*20)
        set1.remove(4)
        println(set1)


        // 4.合并集合
        println("*"*20)
        val set3 = mutable.Set(12,2,3,9)
        println(set1)
        println(set3)
        val set4 = set1 ++ set3
        println(set1)
        println(set3)
        println(set4)

        println("*"*20)
        println(set1)
        println(set3)
        set3 ++= set1  // set1集合不便，set3集合值改变
        println(set1)
        println(set3)
    }
}

8.4 Map集合

8.4.1 不可变Map

object Test {
    def main(args: Array[String]): Unit = {
        // 1.创建Map
        val map1 = Map("a" -> 12, "b" -> 22,"c" -> 11)
        println(map1)

        // 2.遍历元素
        map1.foreach(println)
        println("*"*20)
        map1.foreach((kv:(String,Int)) => println(kv)) // 等效于 map1.foreach(println)

        // 3 取map中所有的key 或者value
        println("*"*20)
        for(key <- map1.keys){
            println(s"${key}--->>>${map1.get(key)}")
        }
        // 4.访问某一个key的value值
        println("*"*20)
        println(map1("a"))
        println(map1.get("a").get)
        println(map1.get("d"))
        println(map1.getOrElse("d",0))
        // 防止无值导致的Some(x)=None，而无get方法，从而造成异常
    }}

8.4.2 可变Map

import scala.collection.mutable

object Test {
    def main(args: Array[String]): Unit = {
        // 1.创建Map
        val map1 = mutable.Map("a" -> 12, "b" -> 22,"c" -> 11)
        println(map1)

        // 2.添加元素
        map1.put("d",10)
        map1.put("e",222)
        map1.+=(("f",666)) // 作用同 map1.put("d",10)
        println(map1)

        // 3.删除元素
        println("*"*20)
        map1.remove("c")
        println(map1.getOrElse("c",0))
        println(map1)
        map1.-=("d")
        println(map1)

        // 4.修改元素
        println("*"*20)
        map1.update("m",222)  // 当map中无对应值时，表现为插入操作
        println(map1)
        map1.update("a",999) // 当map中有对应值时，表现为更新操作
        println(map1)

        // 5.合并Map
        val map2 = Map("x" -> 12, "y" -> 22,"z" -> 11)
        map1 ++= map2
        println(map1)
    }
}

8.5 元组

8.6 集合常用函数

8.6.1 通用属性和操作

object Test {
    def main(args: Array[String]): Unit = {
        val list = List(1, 2, 3, 4)
        val set = Set(1,2,3)

        // 1.获取线性集合长度
        println(list.length)
        println(list.size)
        // 2.获取非线性集合长度
        println(set.size)
        // 3.遍历
        list.foreach(print)
        println()
        set.foreach(print)
        println()
        for(elem <- list){
            print(elem)
        }
        println()
        for(elem <- set){
            print(elem)
        }
        println()

        // 4.迭代器
        for(elem <- list.iterator){
            print(elem)
        }
        println("*"*20)
        // 5.生成字符串
        println(list)
        println(set)
        println(list.mkString(","))

        println("*"*20)
        // 6.是否包含某个元素
        println(list.contains(23))
        println(set.contains(2))
    }
}

8.6.2 衍生集合操作

object Test {
    def main(args: Array[String]): Unit = {
        val list1 = List(1, 2, 3, 4)
        val list2 = List(3,4,243,53)

        // 1.获取集合的头
        println(list1.head)
        // 2.获取集合的尾(这里的尾，指的是除了头的部分)
        println(list1.tail)  // List(2, 3, 4)
        // 3.获取集合的最后一个数据
        println(list1.last)
        // 4.获取集合初始数据(不包含最后一个数据的剩余部分）
        println(list1.init)
        // 5 反转集合
        println(list1.reverse)
        // 6 取前（后）n个元素
        println(list1.take(3)) // 取前3个元素
        println(list1.takeRight(2)) // 取后2个元素
        // 7.去掉前（后）n个元素
        println(list1.drop(2)) // 去掉前2个元素
        println(list1.dropRight(3)) // 去掉后3个元素
        println("*"*20)
        // 8.并集
        val union_ = list1.union(list2)
        println("union_: "+ union_)
        println(list1:::list2) // union等于将集合加在一起
        println(list1 ++ list2)
        println(Set(1,2,3,4).union(Set(3,4,5))) // 如果是set做并集操作，会去重

        // 9.交集
        println("交集"+"*"*20)
        println(list1.intersect(list2))

        // 10.差集
        println("差集"+"*"*20)
        println(list1.diff(list2))
        println(list2.diff(list1))
        // 11.拉链
        println("拉链"+"*"*20)
        println(list1.zip(list2)) // list1中的元素占_v1
        println(list2.zip(list1)) // list2中的元素占_v1
        
        // 12.滑窗
        println("滑窗"+"*"*20)
        for(elem <- list1.sliding(3)){   // 确定滑窗的范围
            println(elem)
        }
        println("-"*20)
        for(elem <- list1.sliding(3,2)){   // 确定滑窗的范围+滑动的距离
            println(elem)
        }
        println("-"*20)
        for(elem <- list1.sliding(3,3)){   // 确定滑窗的范围等于滑动的距离时，又称为滚动窗口
            println(elem)
        }
    }
}

8.6.3 集合计算简单函数

object Test {
    def main(args: Array[String]): Unit = {
        val list1 = List(13, 6, 3, 4)
        val list2 = List(("a",22),("b",2),("c",4),("d",7),("e",9))
        // 1.求和
        println(list1.sum)
        // 2.求乘积
        println(list1.product)
        // 3.求最大值
        println(list1.max)
        // 3.1 maxBy
        println("maxBy"+"*"*20)
        println(list2.max)  // 默认按照._v1进行取值
        println(list2.maxBy((tuple:(String,Int)) => tuple._2 )) // 通过传递匿名函数，按._v2进行取值
        println(list2.maxBy(_._2))  // 简写
        // 4.求最小值
        println("minBy"+"*"*20)
        println(list1.min)
        println(list2.min)
        println(list2.minBy(_._2))  // 简写
        // 5.排序
        // 5.1 sorted 从小到大排序
        println("sorted"+"*"*20)
        println(list1.sorted)
        // 5.2 sorted.reverse  从大到小排序
        println("sorted.reverse"+"*"*20)
        println(list1.sorted.reverse)
        // 5.3 sorted.implicit 传入隐式参数
        println("sorted.implicit"+"*"*20)
        println(list1.sorted(Ordering[Int].reverse))
        // 5.4 sorted.implicit 传入隐式参数
        println("sorted.implicit"+"*"*20)
        println(list1.sorted(Ordering[Int].reverse))
        // 5.5 sortBy
        println("sortBy"+"*"*20)
        println(list2.sortBy(_._2))
        println(list2.sortBy(_._2)(Ordering[Int].reverse)) //逆序排列
        // 5.6 sortWith
        println("sortWith"+"*"*20)
        println(list1.sortWith((a:Int,b:Int) => {a<b} ))  // 从小到大排列
        println(list1.sortWith(_<_)) // 从小到大排列 简化写法
        println(list1.sortWith(_>_)) // 从大到小排列 简化写法
    }
}

8.6.4 集合计算高级函数

8.6.4.1 集合转换操作（Map类）

object Test {
    def main(args: Array[String]): Unit = {
        val list = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
        // 1.过滤:遍历一个集合，并从中获取满足制定条件的元素组成一个新的集合
        println("filter" + "*" * 20)
        println(list.filter((elem: Int) => {
            elem % 2 == 0
        })) // 获取列表中的偶数
        println(list.filter(_ % 2 == 1)) // 获取奇数

        // 2.map： 转换/映射(map) 将集合中的每一个元素映射到某一个函数
        println("map" + "*" * 20)
        println(list.map((elem: Int) => {
            elem * 2
        })) // 集合中的元素值*2
        println(list.map(_ * 2)) // 集合中的元素值*2 简化

        // 3.扁平化 flatten
        println("扁平化" + "*" * 20)
        val nestedList = List(List(1, 2, 43), List(2, 2, 4), List(2, 1), List(2, 4, 6, 8, 3))
        println(nestedList)
        println(nestedList(0) ::: nestedList(1) ::: nestedList(2) ::: nestedList(3)) // 扩展性较差
        println(nestedList.flatten)

        // 4.扁平映射
        println("扁平映射" + "*" * 20)
        val list2: List[String] = List("hello world", "hello java", "hello scala")
        println(list2)
        val splitList2: List[Array[String]] = list2.map(elem => elem.split(" ")) //分词
        println(splitList2.flatten) // 打散
        println(list2.flatMap(elem => elem.split(" "))) //flatMap结合了以上的分词和打散

        // 5.分组
        println("分组" + "*" * 20)
        println(list.groupBy(_ % 2))
        /*  groupBy对列表list进行分组，其中groupBy(f)内函数f的返回值作为map的key,
         待归类的词作为map的value
           // Map(1 -> List(1, 3, 5, 7, 9), 0 -> List(2, 4, 6, 8))
         */
        println(list.groupBy((data:Int)=>{if(data%2==0) "偶数" else "奇数"}))

    }

}

8.6.4.2 集合转换操作（Reduce）

object Test {
    def main(args: Array[String]): Unit = {
        val list = List(1,2,3,4)
        // 1.reduce 简化（归约）：通过指定的逻辑将集合中的数据进行聚合，从而减少数据，获取最终的结果
        println("归约"+"*"*20)
        println(list.reduce(_+_))  // 功能同sum
        println(list.reduceLeft(_+_))  // reduce的底层是reduceLeft
        println(list.reduceRight(_+_))

        // 2.reduceLeft和reduceRight的区别
        val list2 = List(1,2,3,4)
        println(list2.reduceLeft(_-_))  // 结果为-8
        println(list2.reduceRight(_-_)) // 结果为-2 ，源码为递归操作：(1-(2-(3-4)))
    }

}

8.6.4.3 集合转换操作（Fold）

object Test {
    def main(args: Array[String]): Unit = {
        // 1.Fold
        val list = List(1,2,3,4)

        println(list.fold(10)(_+_))  //  执行步骤：10 +1+2+3+4
        println(list.foldLeft(10)(_-_))  //fold的底层是foldLeft 执行步骤：10  -1-2-3-4
        println(list.foldRight(10)(_-_)) // 执行步骤：1-(2-(3-(4-10)))
       
        /*
        fold方法使用了函数柯里化，存在两个参数列表
        第一个参数列表为： 零值（初始值）
        第二个参数列表为： 简化规则
        * */

    }
}

8.6.5 案例

8.7 队列

8.8 并行集合

9 模式匹配

9.1 模式守卫

9.2 模式匹配类型

9.2.1 匹配常量

9.2.2 匹配类型

9.2.3 匹配数组、列表、元组

9.2.4 匹配对象及样例类

10 异常处理

11 隐式转换

11.1 隐式函数

11.2 隐式参数

11.3 隐式解析机制

12 泛型

12.1 协变和逆变

12.2 泛型上下限

标签：String,val,Scala,Int,简明,笔记,Unit,println,def
来源： https://www.cnblogs.com/nuochengze/p/15270455.html