Scala语言:
- scala是一门以jvm为运行环境(scala文件会被编译器编程成.class文件运行在jvm上)的将面向对象和函数式编程(将电脑运算视为函数的计算)结合在一起的静态类型编程语言(ps:静态类型:编译时即知道每一个变量的类型,类型错误的话编译时报异常。动态类型:编译时不知道每一个变量的类型,类型错误的话运行时报异常)。
1、数据类型:byte、Char、short、int、long、float、double和boolean、unit类型。(unit表示无值,相当于void。只有一个实例值,写成())
2、定义变量:var/val。
var name = “zhangsan”
val name: String = “zhangsan”
var和val的区别:val定义的相当于java中final修饰的常量,值只定义一次,后续无法改变。
3、输出:println()
-
'f’是差之旗,允许创建一个格式化的字符。可用%d、%f等,类似于c语言printf
print(f"$name:%s")
printf("%s",name) -
‘s’允许正在处理字符串时直接使用变量
println(s"name= n a m e " ) / / 将 变 量 n a m e 直 接 打 印 在 字 符 串 中 s 和 f 的 区 别 是 s 中 可 以 使 用 name") //将变量name直接打印在字符串中 s和f的区别是s中可以使用 name")//将变量name直接打印在字符串中s和f的区别是s中可以使用{},括号里面可以是任意的表达式
println(s"1 + 1 = 1 + 1 " ) p r i n t l n ( s " {1 + 1}") println(s" 1+1")println(s"{对象.方法()}")
4、for循环:for(i <- 表达式/数组/集合)
- 0 to 5 :[0,5]
- 0 until 5 : [0,5)
- for (i <- arr if i % 2 == 0) {} //取集合中下标为偶数的值
- for ()i <- 1 to 3; j <- 1 to 3 if i != j) {println((10 * i + j) + " ")} //双重for循
- yield 产生新的集合。for循环中的 yield 会把当前的元素记下来,保存在集合中,循环结束后将返回该集合。Scala中for循环是有返回值的。如果被循环的是Map,返回的就是Map,类推。
5、scala中±等操作符以及&|^等作用和java一致,但在scala中这些操作符是方法:a + b 是 a.+(b)的简写(a调用方法+(),b是传参)
6、方法: def 方法名(传参) : 返回值类型 = 方法体
- 例如:def add(x : Int, y : Int) : Int = {x + y} // 其他方法可以不写返回值类型,编译器会自动推断,但是递归函数,必须指定返回值类型。
7、函数的两种定义方式:
- val add1 : (Int, Int) => Int = (x,y) => x+y
- val add = (x : Int, y : Int) => x+y
8、传值调用和传名调用:
var count = 10
def del() : Int = {count = count - 1}
printByName(del)
- 传值调用
`def printByName(x : Int) = {for(a->0 to 3) {println(s"${x}")}
打印结果:
9
9
9
9
传值调用只会在方法调用,得到值。
- 传名调用
def printByName(x : => Int) = {for(a->0 to 3) {println(s"${x}")}
打印结果:
9
8
7
6
传名调用x:=>Int表示一个方法的签名 =>没有参数,返回值为Int的函数,作为参数,每次调用x都会执行一次函数。隐式将x转换成函数,将del的方法名称传递到方法的内部执行。传递的是一个引用。
8、可变参数:
def add(intValue: Int, ints : Int*) : Int = {var sum = intValue for(v <- ints){sum+=v} sum}
9、高阶函数:将其他函数作为参数或者其结果是函数的函数
10、柯里化:将入参为2个的函数变成入参为1个的函数的过程。新的函数返回一个以原有第二个参数为参数的函数。函数经过柯里化后通用性降低,适用性提高。
11、偏函数:def method : partialFunction[参数类型,返回值类型] = {case => }
12、数组:
- 定义: val arr = new ArrayInt 不可变数组:内容可变,长度不可变
val arr1 = Array{1,2,3} //相当于Array.apply(1,2,3) - map(映射)方法:arr经过map操作后返回一个新的数组类型,本来arr的内部内容没有改变。例如:将数组里的元素都乘以10
val arr = Array{1,3,5,7}
1、arr.map((x:Int)=>x*10)
2、arr.map(x=>x*10)
3、arr.map(_ * 10)
- flatten(扁平化操作):
val arr = Array("hello world","word count")
arr.map(_,split(" ")).flatten
原先只是对arr中两个元素根据空格进行切分,会生成两个array,flatten就是将两个array取消掉,使arr里面仅包含切分后的元素。
arr.map(,split(" "))的结果:Array[Array(hello,world),Array(word,count)]
arr.map(,split(" ")).flatten的结果:Array(hello,world,word,count)
-
flatMap:先map在flatten
arr.flatMap(,split(" "))的结果相当于arr.map(,split(" ")).flatten -
foreach(循环遍历):
arr.flatMap(_,split(" ")).foreach(x => println(x)) //打印出数组中所有元素
13、集合:集合分为可变(mutable)和不可变(immutable)两种类型。不可变集合初始化后就不再改变,内容以及长度都不可变。(定长数组:Array,变长数组:ArrayBuffer)
14、seq序列:
- Nil表示空列表(List())
- 列表要么为空(Nil)要么是一个head元素加上一个tail元素(除了head,其他元素都是tail里的)。
- ::操作符是将给定的head和tail创建一个新的列表,::是一个右优先操作符。
- list.++ -->两个集合相加返回一个新的集合
- list.++: -->两个集合相加返回一个新的集合,右边的集合为头部
- list +: /list :+ --> :在+右边表示在list头部添加,反之则在尾部添加
- llist :: list1 --> list(List(list),list1)
- list ::: list1 --> list(list,list1)
- list.count(x => x>2) -->集合中元素大于2的个数
- list.filter(x => x >=3) -->过滤集合中符合条件表达式的值作为集合返回
- list.sortBy(x => x) -->升序排序 (-x则为降序)
- list.sortWith() -->排序
val lists = List(("a","b",1),("a","c",2))
lists.sortWith((x,y) => x._3 > y._3) //降序排序
- list.grouped -->按指定数量分组,每组有 size 数量个元素,返回一个集合
- list.groupBy -->按条件分组
- list.fold(初始值)(函数) -->函数(函数(初始值,list._1),list._2)…
- list.union -->将两个集合的元素合在一起
- list.diff(list2) -->两个集合求差集
- list.intersect(list2) -->两个集合求交集
- list.zip(list2) -->将两个集合对应角标的元素组合在一起
- list.mkString(" ") -->将list元素转成字符串,以括号里的内容连接
- list.slice(index1, index2) -->截取
- list.par -->并行化集合
15、set集合:无序并且不重复(hashset是可变集合,set是不可变的)
16、对象:object是一个单例的对象,并且其成员变量和方法都是静态的,不能New,通过对象.属性调用。
17、class:
1、定义在类名后面的构造器叫做主构造器,一个类中主构造器只能有一个。
2、如果主构造器中赋值的成员属性没有var/val修饰,则外部不可访问该属性。
3、主构造器中定位的属性会成为成员属性
4、成员属性用var修饰,外部可以访问也可以改值。用val修饰,外部只可取值,也就是只提供getter方法。
5、辅助构造器中必须先调用主构造器。
6、类前加private/private[this]修饰,则该类仅可被一个包下的其他类可见,当前包下的子包也不可见。private[包名]表示该类在当前包以及其子包可见。
Object和Class的区别:
1、object中的方法和字段都是静态的,可以直接用对象名.方法/变量方式调用。object的构造器是在第一次使用的时候调用,没调用过便不会执行。object有class的所有特性,还可以扩展class一个或者多个特质。object构造器无参。,main方法必须在Object中调用,因为main方法是static的,而scala没有static关键字,所以在Object中调用,模拟静态.
2、
18、伴生对象(类):同一个scala源中名称相同的class和object。在伴生对象中可以访问类的私用成员和属性,类只会被编译,不能直接被执行。class有了Object即可得到静态.
19、trait(特质):相当于java中的interface接口,但是可以定义有实现的方法也可以定义没有实现的方法。如果特质中没有实现的方法,其子类可以不加override关键字,如果特质中方法已经实现,那子类中重写必须加上override关键字。scala中可以动态的混入n个特质。(val s = new 对象 with 特质 with 特质2 … (s可以同时调用所有混入的特质的方法))
20、abstract (抽象类):可以有没有实现的方法,也可以有具体实现的方法。
和特质的区别:
1、第一个继承抽象类或者特质,只能使用extends,如果想继承多个特质,可以在extends后面使用with关键字。
2、with后面只能是特质。