基于JVM的编程语言Scala
Scala介绍
首先Scala是一门基于JVM的编程语言，具有很好的兼容性和并发性。
Scala六大特征
Java和Scala可以无缝混编
类型推测（自动推测类型）
并发和分布式
特质trait，特征（类似于java中interface和abstract结合，可以实现多继承）
模式匹配（类似于java switch）
高阶函数（包含两种：①函数的参数是函数②函数的返回是函数）
Scala的安装与配置
1，下载安装包
官网下载scala2.10：https://www.scala-lang.org/download/2.10.4.html
2，配置环境变量（和配置jdk相似）
//首先配置SCALA_HOME
SCALA_HOME=“scala的解压路径”
//然后配置path
;%SCALA_HOME%\bin;%SCALA_HOME%\jre\bin
3，编译器配置
3.1，eclipse配置Scala插件
下载插件（一定要对应eclipse版本下载）
http://scala-ide.org/download/prev-stable.html
解压后把features和plugins两个文件夹拷贝到eclipse安装目录中的” dropins/scala”目录下。
3.2，或者使用scala ide
下载网址：http://scala-ide.org/download/sdk.html
3.3，idea中配置scala插件
①打开idea,close项目后，点击Configure->Plugins
②搜索scala，点击安装
③设置jdk，打开Project Structure,点击new 选择安装好的jdk路径
④创建scala项目，配置scala sdk(Software Development Kit)
Scala基础
1，数据类型
2. 变量和常量的声明
变量 :用 var 定义 ，可修改
常量 :用 val 定义，不可修改
3. 类和对象
//创建类
class Person{
val name = "zhangsan"
val age = 18
def sayName() = {
"my name is "+ name
}
}
//创建对象
object Lesson_Class {
def main(args: Array[String]): Unit = {
val person = new Person()
println(person.age);
println(person.sayName())
}
}
//伴生类和伴生对象
class Person(xname :String , xage :Int){
var name = Person.name
val age = xage
var gender = "m"
def this(name:String,age:Int,g:String){
this(name,age)
gender = g
}
def sayName() = {
"my name is "+ name
}
}
object Person {
val name = "zhangsanfeng"
def main(args: Array[String]): Unit = {
val person = new Person("wagnwu",10,"f")
println(person.age);
println(person.sayName())
println(person.gender)
}
}
4. if else
略
5. for ,while,do…while
/**
* to和until
* 例：
* 1 to 10 返回1到10的Range数组，包含10
* 1 until 10 返回1到10 Range数组 ，不包含10
*/
println(1 to 10 )//打印 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
println(1.to(10))//与上面等价，打印 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
println(1 to (10 ,2))//步长为2，从1开始打印 ，1,3,5,7,9
println(1.to(10, 2))
println(1 until 10 ) //不包含最后一个数，打印 1,2,3,4,5,6,7,8,9
println(1.until(10))//与上面等价
println(1 until (10 ,3 ))//步长为2，从1开始打印，打印1,4,7
/**
* for 循环
*
*/
for( i <- 1 to 10 ){
println(i)
}
//例子： 打印小九九
for(i <- 1 until 10 ;j <- 1 until 10){
if(i>=j){
print(i +" * " + j + " = "+ i*j+" ")
}
if(i==j ){
println()
}
}
//可以在for循环中加入条件判断
for(i<- 1 to 10 ;if (i%2) == 0 ;if (i == 4) ){
println(i)
}
//scala中不能使用count++，count—只能使用count = count+1 ，count += 1
//将for中的符合条件的元素通过yield关键字返回成一个集合
val list = for(i <- 1 to 10 ; if(i > 5 )) yield i
for( w <- list ){
println(w)
}
Scala函数
1. Scala函数的定义
def fun (a: Int , b: Int ) : Unit = {
println(a+b)
}
fun(1,1)
def fun1 (a : Int , b : Int)= a+b
println(fun1(1,2))
- 函数定义语法 用def来定义
- 可以定义传入的参数，要指定传入参数的类型
- 方法可以写返回值的类型也可以不写，会自动推断，有时候不能省略，必须写，比如在递归函数中或者函数的返回值是函数类型的时候。
- scala中函数有返回值时，可以写return，也可以不写return，会把函数中最后一行当做结果返回。当写return时，必须要写函数的返回值。
- 如果返回值可以一行搞定，可以将{}省略不写
- 传递给方法的参数可以在方法中使用，并且scala规定方法的传过来的参数为val的，不是var的。
- 如果去掉方法体前面的等号，那么这个方法返回类型必定是Unit的。这种说法无论方法体里面什么逻辑都成立，scala可以把任意类型转换为Unit.假设，里面的逻辑最后返回了一个string，那么这个返回值会被转换成Unit，并且值会被丢弃。
2. 递归函数
/**
* 递归函数
* 5的阶乘
*/
def fun2(num :Int) :Int= {
if(num ==1)
num
else
num * fun2(num-1)
}
print(fun2(5))
3. 包含参数默认值的函数
/**
* 包含默认参数值的函数
* 注意：
* 1.默认值的函数中，如果传入的参数个数与函数定义相同，则传入的数值会覆盖默认值
* 2.如果不想覆盖默认值，传入的参数个数小于定义的函数的参数，则需要指定参数名称
*/
def fun3(a :Int = 10,b:Int) = {
println(a+b)
}
fun3(b=2)
4. 可变参数个数的函数
/**
* 可变参数个数的函数
* 注意：多个参数逗号分开
*/
def fun4(elements :Int*)={
var sum = 0;
for(elem <- elements){
sum += elem
}
sum
}
println(fun4(1,2,3,4))
5. 匿名函数
/**
* 匿名函数
* 1.有参数匿名函数
* 2.无参数匿名函数
* 3.有返回值的匿名函数
* 注意：
* 可以将匿名函数返回给定义的一个变量
*/
//有参数匿名函数
val value1 = (a : Int) => {
println(a)
}
value1(1)
//无参数匿名函数
val value2 = ()=>{
println("我爱Angelababy")
}
value2()
//有返回值的匿名函数
val value3 = (a:Int,b:Int) =>{
a+b
}
println(value3(4,4))
6. 嵌套函数
/**
* 嵌套函数
* 例如：嵌套函数求5的阶乘
*/
def fun5(num:Int)={
def fun6(a:Int,b:Int):Int={
if(a == 1){
b
}else{
fun6(a-1,a*b)
}
}
fun6(num,1)
}
println(fun5(5))
7. 偏应用函数
/**
* 偏应用函数
*/
def log(date :Date, s :String)= {
println("date is "+ date +",log is "+ s)
}
val date = new Date()
log(date ,"log1")
log(date ,"log2")
log(date ,"log3")
//想要调用log，以上变化的是第二个参数，可以用偏应用函数处理
val logWithDate = log(date,_:String)
logWithDate("log11")
logWithDate("log22")
logWithDate("log33")
8. 高阶函数
/**
* 高阶函数
* 函数的参数是函数 或者函数的返回是函数 或者函数的参数和返回都是函数
*/
//函数的参数是函数
def hightFun(f : (Int,Int) =>Int, a:Int ) : Int = {
f(a,100)
}
def f(v1 :Int,v2: Int):Int = {
v1+v2
}
println(hightFun(f, 1))
//函数的返回是函数
//1，2,3,4相加
def hightFun2(a : Int,b:Int) : (Int,Int)=>Int = {
def f2 (v1: Int,v2:Int) :Int = {
v1+v2+a+b
}
f2
}
println(hightFun2(1,2)(3,4))
//函数的参数是函数，函数的返回是函数
def hightFun3(f : (Int ,Int) => Int) : (Int,Int) => Int = {
f
}
println(hightFun3(f)(100,200))
println(hightFun3((a,b) =>{a+b})(200,200))
//以上这句话还可以写成这样
//如果函数的参数在方法体中只使用了一次 那么可以写成_表示
println(hightFun3(_+_)(200,200))
9. 柯里化函数
/**
* 柯里化函数
*/
def fun7(a :Int,b:Int)(c:Int,d:Int) = {
a+b+c+d
}
println(fun7(1,2)(3,4))
Scala字符串
/**
* String && StringBuilder
*/
val str = "abcd"
val str1 = "ABCD"
println(str.indexOf(97))
println(str.indexOf("b"))
println(str==str1)
/**
* compareToIgnoreCase
*
* 如果参数字符串等于此字符串，则返回值 0；
* 如果此字符串小于字符串参数，则返回一个小于 0 的值；
* 如果此字符串大于字符串参数，则返回一个大于 0 的值。
*
*/
println(str.compareToIgnoreCase(str1))
val strBuilder = new StringBuilder
strBuilder.append("abc")
// strBuilder.+('d')
strBuilder+ 'd'
// strBuilder.++=("efg")
strBuilder++= "efg"
// strBuilder.+=('h')
strBuilder+= 'h'
strBuilder.append(1.0)
strBuilder.append(18f)
println(strBuilder)
集合
1,数组
/**
* 创建数组两种方式：
* 1.new Array[String](3)
* 2.直接Array
*/
//创建类型为Int 长度为3的数组
val arr1 = new Array[Int](3)
//创建String 类型的数组，直接赋值
val arr2 = Array[String]("s100","s200","s300")
//赋值
arr1(0) = 100
arr1(1) = 200
arr1(2) = 300
/**
* 遍历两种方式
*/
for(i <- arr1){
println(i)
}
arr1.foreach(i => {
println(i)
})
for(s <- arr2){
println(s)
}
arr2.foreach {
x => println(x)
}
/**
* 创建二维数组和遍历
*/
val arr3 = new Array[Array[String]](3)
arr3(0)=Array("1","2","3")
arr3(1)=Array("4","5","6")
arr3(2)=Array("7","8","9")
for(i <- 0 until arr3.length){
for(j <- 0 until arr3(i).length){
print(arr3(i)(j)+" ")
}
println()
}
var count = 0
for(arr <- arr3 ;i <- arr){
if(count%3 == 0){
println()
}
print(i+" ")
count +=1
}
arr3.foreach { arr => {
arr.foreach { println }
}}
val arr4 = Array[Array[Int]](Array(1,2,3),Array(4,5,6))
arr4.foreach { arr => {
arr.foreach(i => {
println(i)
})
}}
println("-------")
for(arr <- arr4;i <- arr){
println(i)
}
2.list
//创建
val list = List(1,2,3,4,5)
//遍历
list.foreach { x => println(x)}
// list.foreach { println}
//filter
val list1 = list.filter { x => x>3 }
list1.foreach { println}
//count
val value = list1.count { x => x>3 }
println(value)
//map
val nameList = List(
"hello bjsxt",
"hello xasxt",
"hello shsxt"
)
val mapResult:List[Array[String]] = nameList.map{ x => x.split(" ") }
mapResult.foreach{println}
//flatmap
val flatMapResult : List[String] = nameList.flatMap{ x => x.split(" ") }
flatMapResult.foreach { println }
3.set
//创建
val set1 = Set(1,2,3,4,4)
val set2 = Set(1,2,5)
//遍历
//注意：set会自动去重
set1.foreach { println}
for(s <- set1){
println(s)
}
println("*******")
/**
* 方法举例
*/
//交集
val set3 = set1.intersect(set2)
set3.foreach{println}
val set4 = set1.&(set2)
set4.foreach{println}
println("*******")
//差集
set1.diff(set2).foreach { println }
set1.&~(set2).foreach { println }
//子集
set1.subsetOf(set2)
//最大值
println(set1.max)
//最小值
println(set1.min)
println("****")
//转成数组，list
set1.toArray.foreach{println}
println("****")
set1.toList.foreach{println}
//mkString
println(set1.mkString)
println(set1.mkString("\t"))
4.Map KV键值对集合