scala可运行文件的注意事项1、如果一个scala文件要运行class要改成object2、如果是class就仅单纯代表一个类如果是object代表的是单例对象3、scala语法中一句话结束不需要加分号4、scala文件中可以无缝使用java中的类和方法

object

java语言的输出一句话System.out.println(hello

world)}

1、变量一旦定义它的类型就确定可以不用手动指定类型根据赋的值自动推断出类型*

变量名:数据类型

scala中的数据类型和java的数据类型对应关系Byte-Double

java:

100println(a1)//获取变量的类型println(a1.getClass)//

200println(a1)var

为一个函数底层通过StringBuilder来实现字符的链接println(

50)字符串

|这是一个长字符串|真的很长|注意了|.stripMargin

println(sql)//

String类和Java是一个共同的字符串类String类中的功能在scala中正常使用var

val

scala中的数组下标也是从0开始的不过取的时候要使用arr1(0)

println(arr1(0))

3、使用scala的特有函数mkString前提条件是有一组可拼接的序列*

s{变量}”

res2.append(q1).append(,).append(q2).append(,).append(q3)

println(res2)var

scala.util.control.Breaks.break*///TODO

在break后程序的执行结束如若想继续执行那么需要再加上一个breakablebreakable{for

10)

}break;}println(e)}}println(太牛了)

}IO流

FileReader(scala/data/words.txt))var

line:String

br.readLine()}//scala中的读取文件的方式//Source.fromFil

底层是使用了字节输入流读取数据FileInputStreamval

bs:

Source.fromFile(scala/data/words.txt)//

lineIterator:

lineIterator.next()println(s)}//

既然返回的是一个迭代器那么就可以使用for循环来进行输出for

bs.getLines())

FileWriter对象被用作参数来创建一个BufferedWriter对象。

*

这样就可以通过BufferedWriter来写入字符而实际的写入操作包括可能的缓冲将由BufferedWriter处理。

*/val

new

FileWriter(scala/data/words2.txt))bw.write(写入数据)//

newLine()方法用于写入一个行分隔符bw.newLine()bw.write(太棒了)//flush()方法用于将缓冲区中的数据强制写入到底层输出流如FileWriter中并清空缓冲区。

bw.flush()//TODO

手动抛出异常

FileReader(scala/data/words888.txt))val

new

Scanner(System.in)print(输入除数)val

cs:

异常被捕获后后续代码都可以运行}catch{//类似于sql语句中case

when//

e:ArithmeticExceptionprintln(除0异常)e.printStackTrace()case

e:ArrayIndexOutOfBoundsExceptionprintln(数组越界异常)//

TODO

今后finally中的处理大部分情况下都与释放资源有关println(这是finally代码块)}println(hello

world)

22)println(res4)//调用形式1object中的函数可以使用类名调用,类似于静态一样val

res5:

200)println(res5)//调用形式2object中的函数调用时可以省略类名val

res6:

如果方法调用的函数只有一个参数的时候可以将.和小括号用空格代替调用val

res9:

如果定义的时候没有小括号调用的时候就不需要加小括号无需传入参数show}//定义格式1如果函数有返回值且最后一句话作为返回值的话return关键字可以不写def

add3(a1:

b1}//定义格式2如果函数体中只有一句实现那么大括号也可以不写def

add4(a1:

b1//定义格式3如果函数没有参数的时候,小括号省略不写def

show

println(好好学习天天向上)//需求1定义一个求两个数之和的函数返回结果def

add(a1:

函数或者方法必须定义在class或者object中否则将会报错无法进行编译

//def

Demo1{//这里叫方法将来调用时需要创建该类的对象才可以调用def

add2(a1:

factorial(5)println(s5的阶乘是$res1)println(s5的阶乘是${Demo6Function

factorial

男)println(s2)//如果调用的是一个类的无参构造方法new的时候小括号可以不用写val

s3:

Student2s3.fun1()//也可以使用多态的方式创建对象val

s4:Object

1、在scala中构造方法的编写和在java中不太一样类所拥有的大括号中都是构造代码块的内容*

class

这个下划线就表示将来不传值时会赋予其默认值。

String的默认值是一个特殊的值即nullvar

_gender:

在创建类的对象时若传递三个参数则会使用该构造方法进行初始化对象def

this(name:

以确保对象被正确初始化。

需要注意的是this(...)调用必须是构造器体中的第一条语句。

*/this(name:

String,

此处定义的类的父类都是Object,重写继承自父类的toString方法*/override

def

较少用户创建类所编写代码量只需要定义成员变量即可自动扩充成员变量构造方法重写toString方法*/

object

学习)println(t1)println(t1.name)println(t1.age)println(t1.like)t1.like

敲代码println(t1)}

样例类中的成员变量编译后默认是被jvm添加了final关键字用户是改变不了的*

case

Teacher(name:String,age:Int,var

object

若定义在object中那么可以直接用Book(中华上下五千年,

b1:

当看到类抽象类接口的时候今后无论是参数类型还是返回值类型都需要提供对应的实现类对象**

参数类型返回值类型**/将函数当作对象赋值给类型是函数类型的变量

fun1(s:

fun1(1000)println(res1)//定义变量的方式定义一个函数//将函数当作对象赋值给类型是函数类型的变量将来可以直接通过变量调用函数val

fun2:

本质上是将函数A的处理逻辑主体传给了函数B在函数B中使用这个处理逻辑*/

show1

fun1(show2)println(res2)//定义一个函数fun1,

fun1(s:

show2)println(res1)//使用lambda表达式改写函数作为参数传递的调用形式(s:

String)

s.toInt1000)//在scala中数据类型可以自动类型推断fun1(2000,

s.toInt1000)//如果当作参数的函数的参数只在函数主体使用了一次那么可以使用_代替fun1(2000,

_.toInt1000)val

_.toInt1000)println(res2)函数当作参数传递的应用

object

Unit//foreach函数需要一个参数它和数组元素一样的类型返回值是Unit的函数//foreach函数的主要作用是将调用该方法的序列中的元素依次取出并传递给传入的函数进行处理arr1.foreach(fun1)//

println(x:

Any可以接收任意的数据类型元素arr1.foreach(println)}

}函数当作返回值返回

resFun1(1000)println(res1)//定义方式2(是方式1的简化写法):/***

方式2这种将参数分开定义今后调用时可以分开传递这种做法在scala中叫做函数柯里化**

1、本身是一个数学界的一个名词本意是原来一次传递多个参数现在被改成了可以分开传递的形式这种做法叫做柯里化*

2、在scala中体现柯里化指的是函数的返回值也是一个函数将来调用时参数可以分开传递。

*

def

println(sres1:$res1,res2:$res2,res3:$res3)集合

ArrayList

util.ArrayList[Int]()list1.add(11)list1.add(123)list1.add(22)list1.add(31)list1.add(17)println(list1)println(

50)//scala中的for循环只能遍历scala中的序列无法遍历java的序列//

for

//scala推荐获取第一个元素的方式是调用head函数scala更希望使用这种方式来获取第一个元素的值

println(list2.head)

34|11|22|11|33|44|55|22|75|987|1|12|34|66|77

println(

依次取出元素进行后面函数逻辑有返回值返回新的集合filter:

排序flatMap:

将集合中的元素依次取出传入到后面的函数中注意没有返回值的要么就输出要么就其他方式处理掉了

//def

println(sresList6:$resList6)filter

println(

println(sresList7:$resList7)sortBy、sortWith

sortBy:

println(sresList9:$resList9)flatMap

flatMap:

set集合scala中的Set集合也是不可变的除了排序相关的函数以外List集合有的高阶函数Set集合也有*/val

set1:

set1.intersect(set2)println(sset1:

${set2})println(s交集:

list1.toSetprintln(slist1:${list1})println(sresSet4:${resSet4})println(

50)//Set-Listval

resSet4.toList.sortBy((e:Int)e)println(slist1:${list1})println(sresSet4:${resSet4})println(slist2:${list2})}Mutable下的可变的集合

import

scala.collection.mutable.ListBufferobject

Demo16Mutable

通过观察api发现不可变的集合是属于scala.collection.immutable包下的*

如果将来想要使用可变的集合就要去scala.collection.mutable包下寻找*///创建一个可变的List集合val

listBuffer1:

ListBuffer[Int]println(listBuffer1)listBuffer1.(11)listBuffer1.(22)listBuffer1.(33)listBuffer1.(11)listBuffer1.(55)listBuffer1.(22)listBuffer1.(33)listBuffer1.(66)listBuffer1.(33)println(listBuffer1)println(

50)//获取元素println(listBuffer1(2))println(listBuffer1.head)println(listBuffer1.last)/***

这里的可变List集合上午说的功能函数这里都可以调用*/println(

22,

//从左向右找元素只会删除第一次找到的println(listBuffer1)println(

50)//批量添加元素listBuffer1.(100,220,300,400)println(listBuffer1)println(

50)val

77)listBuffer1.(list1)println(listBuffer1)/***

hashSet1:

大小,值是固定的根据创建的类来定每个元素的数据类型可以是不一样最高可以创建存储22个元素的元组*/

object

{//创建Map集合//键是唯一的键一样的时候值会被覆盖val

map1:

get函数获取键不存在返回Noneprintln(map1.getOrElse(1006,

0))

//根据键获取值若键不存在返回提供的默认值默认值的类型可以是任意数据类型println(

50)val

50)//遍历Map集合第一种方式先获取所有的键根据键获取每个值val

keys2:

50)//遍历Map集合第二种方式先获取所有的键根据键获取每个值for

(kv

直接遍历map集合得到每一个键值对组成的元组println(s键:${kv._1},

值:${kv._2})}println(

50)//遍历Map集合第三种方式先获取所有的键根据键获取每个值map1.foreach((kv:

(Int,

Source.fromFile(scala/data/words.txt).getLines().toListprintln(lineList)//2、将每一行数据按照|切分并且进行扁平化val

wordsList:

line.split(\\|))println(wordsList)//3、根据元素进行分组val

wordKV:

wordCount.toListresultList.foreach(println)println(*50)/***

使用链式调用的方式简写*/Source.fromFile(scala/data/words.txt).getLines().toList.flatMap((line:String)line.split(\\|)).groupBy((e:String)e).map((kv:

(String,

count)}).toList.foreach(println)println(

50)/***

使用链式调用的方式简写*/Source.fromFile(scala/data/words.txt).getLines().toList.flatMap(_.split(\\|)).groupBy((e:String)e).map((kv:

(String,

kv._2.size)).toList.foreach(println)}

}JDBC

{//1、注册驱动若是8及其以后的版本需要mysql.cg.jdbcClass.forName(com.mysql.jdbc.Driver)//2、创建数据库链接对象//jdbc:数据库名://host:port/数据库?xxxxxxxxxxxxval

conn:

DriverManager.getConnection(jdbc:mysql://192.168.128.100:3306/studentdb?useUnicodetruecharacterEncodingUTF-8useSSLfalse,

root,

preparedStatement.setInt(1,23)//

传入参数防止sql注入preparedStatement.setInt(1,

60)val

preparedStatement.executeQuery()//5、如果第4步是查询的话分析查询结果while

student_id:

resultSet.getString(student_id)val

cource_id:

resultSet.getString(cource_id)val

score:

resultSet.getInt(score)println(s学号$student_id,

课程号$cource_id,

分数$score)}//6、释放资源conn.close()}

}Json

Source.fromFile(scala/data/stu.json).getLines().toListval

jsonStr:

lineList.mkString(\n)println(jsonStr)//使用fastjson包中的JSON类将一个字符串转成json对象//转成json对象之后可以通过键获取值

parseObject

JSON.parseObject(jsonStr)println(jsonObj1)val

s1:

jsonObj1.getString(student_list)println(s1)//parseArray将一个[{},{}]变成一个元素是json对象的数组val

jSONArray:

obj1.getString(like)println(s${name}的爱好是${like})i

import

util.ArrayList[Int]()array1.add(11)array1.add(22)array1.add(33)array1.add(66)array1.add(55)array1.add(44)println(array1)/***

java中的集合本来是没有转换scala的功能需要导入隐式转换*

scala.collection.JavaConverters._val

list1:

array1.asScala.toListprintln(list1)/***

list2:

模式匹配就可以帮助我们开发的时候减少代码量让逻辑看起来更加清晰以及可以避免一些异常*

语法*

Scanner(System.in)println(请输入要查询的键)val

key:

Source.fromFile(scala/data/students.txt).getLines().toListval

stuArrayList:

line.split(,))stuArrayList.map((e:Array[String]){val

id:

clazz)}).foreach(println)stuArrayList.map{case

Array(id:

scala.language.implicitConversionsobject

Demo24implicit

一个A类型将来会自动地转换成另一个B类型,类型可以是基本数据类型也可以是引用数据类型**

显式转换*/

1000}//调用函数println(fun1(100))println(fun1(200))

若已设置隐式转换函数则会报错因为不知道要不要交给隐式转换函数处理//需求调用fun1函数就只传字符串不会报错//定义隐式转换函数//在需要返回值类型的功能的时候自动地根据已有隐式转换函数将参数的类型转成返回值的类型implicit

def

}//调用函数println(fun1(100))println(fun1(200))

println(fun1(300))//

scala/data/students.txt.getLines().toList

val

scala/data/scores.txt.getLines().toListprintln(1000

500)

字符串中没有-减法功能自动使用隐式转换中的函数将字符串转成数字做减法println(2000

500)

字符串中没有-减法功能自动使用隐式转换中的函数将字符串转成数字做减法}

}object

Demo12(scala/data/students.txt)

val

scala/data/students.txt.show1()val

scoreList:

scala/data/score.txt.show1()//TODO

modifier

{//implicit使用的地方不能超过object作用域将其放在object

Demo25implicit中//

使用对应的上其参数类型的一个量即可调用类中的方法implicit

class

{Source.fromFile(path).getLines().toList}def

f(){println(s好好学习天天向上$path)}}}3、隐式转换变量

import

{Source.fromFile(scala/data/students.txt)(Codec(GBK)).getLines().toList//

def

a2//定义一个隐式转换变量若上述函数在被调用时没有传入第二个隐式转换参数时则会使用下面设定的默认值implicit

var

只传入一个参数值后调用fun1返回的为一个数值。

若是没有定义隐式转换变量val

res1: