协变逆变
class Animal{
def eat():Unit ={
println("动物吃东西")
}
}
class Cat extends Animal{
override def eat():Unit ={
println("猫科动物吃肉")
}
}
class Tiger extends Cat{
override def eat():Unit={
println("老虎吃人")
}
}
class Invariant[T]{}//不变
class Inversion[-T]{}//逆变
class Covariant[+T]{}//协变
def main(args:Array[String]):Unit={
var tiger:Tiger = new Tiger //正常创建对象
var cat:Cat = new Tiger//父类的引用指向子类的对象
//不变
var tigerObj:Invariant[Tiger] = new Invariant[Tiger]
//逆变
var tigerObj1:Inversion[Tiger]=new Inversion[Tiger]
var tigerObj2:Inversion[Tiger]=new Inversion[Cat]
//协变
var tigerObj3:Covariant[Cat]=new Covariant[Cat]
var tigerObj4:Covariant[Cat]=new Covariant[Tiger]
}
//演示
def fun:PartialFunction[Cat,Cat]={//默认前- 后+
//传入的是Cat 和Cat的父类
case x:Tiger =>x
case _=> new Cat
}
var cat= new Cat
val cat1:Cat = fun(cat:Cat)
cat1.eat() //猫科动物吃肉
使用jdbc连接数据库
导包：mysql-connector-java-5.1.38.jar
file - project structure-module-dependencies - + -包的路径-apply
class MysqlDemo{
//定义属性
private var driver="com.mysql.jdbc.Driver"
private var url = "jdbc:mysql://192.168.232.211:3306"
private var user = "root"
private var password ="ok"
//构造函数
def this(dirver:String,url:String,user:String,password:String){
this()
this.driver = driver
this.url = url
this.user= user
this.password = password
}
//创建连接
def conn():Connection={
Class.forName(driver)//加载驱动
var connection:Connection=DriverManager.getConnection(url,user,password)
connection
}
def insert(id:Int,name:String,age:Int):Unit={
var insertSql = "insert into stu.student(id,name,age)values(?,?,?)"
//创建prepareStatement对象
val prep = conn().prepareStatement(insertSql)
prep.setInt(1,id)//在sql语句的第一个问号位置填充id，类型是Int
prep.setString(2,name)
prep.setInt(3,age)
val i = prep.executeUpdate()
i
}
def select():Unit={
var sqlString="select id,name,age from stu.student"
//创建statement对象
val rs = conn().createStatement.executeQuery(sqlString)
while(rs.next()){
val id = rs.getInt(1)
val name = rs.getString(2)
val age = rs.getInt(3)
println("学号:%d 姓名:%S 年龄:%d".format(id,name,age))
}
}
}
object MysqlDemo{
def apply():MysqlDemo = new MysqlDemo()
def apply(driver:String,url:String,userName:String,password:String):MysqlDemo = new MysqlDemo(driver,url,userName,password)
}
def main(args:Array[String]):Unit={
val demo = MysqlDemo()
println(demo.insert(1,"ls",18))
demo.select()
}
使用隐式类
package cn.kgc.kb11
import java.sql.{Connection, DriverManager}
import cn.kgc.kb11.stu.MysqlDemo
object Implicite {
//隐式类
implicit class opera(ce:CeShi){
def sum(a:Int,b:Int):Int = {
a+b
}
}
implicit class operator(mysqlDemo:MysqlDemo){
var driver="com.mysql.jdbc.Driver"
var url="jdbc:mysql://192.168.232.211:3306"
var user="root"
var password="ok"
// def this(driver:String,url:String,userName:String,pwd:String){
// this()
// this.driver=driver
// this.url=url
// this.user=userName
// this.password=pwd
// }
// private var connection:Connection =_
def conn():Connection={
Class.forName(driver)
var connection:Connection=DriverManager.getConnection(url, user, password)
connection
}
def insert(id:Int,name:String,age:Int):Int={
var inserSql="insert into stu.student(id,name,age) values(?,?,?)"
val prep=conn().prepareStatement(inserSql)
prep.setInt(1,id)
prep.setString(2,name)
prep.setInt(3,age)
val i = prep.executeUpdate()
// var i:Int = connection.createStatement.executeUpdate(inserSql)
i
}
def insert():Int={
var inserSql="insert into stu.student(id,name,age) values(1,'zs',21)"
var i:Int = conn().createStatement.executeUpdate(inserSql)
i
}
def select():Unit={
var sqlString="select id,name,age from stu.student"
val rs = conn().createStatement.executeQuery(sqlString)
while(rs.next()){
val id = rs.getInt(1)
val name = rs.getString(2)
val age = rs.getInt(3)
println("学号:%d 姓名:%s 年龄:%d".format(id,name,age))
}
}
}
}
package cn.kgc.kb11.stu
import java.sql.{Connection, DriverManager, ResultSet}
//file- project structure -module- dependencies-+
import cn.kgc.kb11.Implicite._
class MysqlDemo {
// private var driver="com.mysql.jdbc.Driver"
// private var url="jdbc:mysql://192.168.232.211:3306"
// private var user="root"
// private var password="ok"
//
// def this(driver:String,url:String,userName:String,pwd:String){
// this()
// this.driver=driver
// this.url=url
// this.user=userName
// this.password=pwd
// }
private var connection:Connection =_
// def conn():Connection={
// Class.forName(driver)
// var connection:Connection=DriverManager.getConnection(url, user, password)
// connection
// }
// def insert(id:Int,name:String,age:Int):Int={
// var inserSql="insert into stu.student(id,name,age) values(?,?,?)"
// val prep=conn().prepareStatement(inserSql)
// prep.setInt(1,id)
// prep.setString(2,name)
// prep.setInt(3,age)
//
// val i = prep.executeUpdate()
//
// // var i:Int = connection.createStatement.executeUpdate(inserSql)
// i
// }
// def insert():Int={
// var inserSql="insert into stu.student(id,name,age) values(1,'zs',21)"
// var i:Int = conn().createStatement.executeUpdate(inserSql)
// i
// }
// def select():Unit={
// var sqlString="select id,name,age from stu.student"
// val rs = conn().createStatement.executeQuery(sqlString)
// while(rs.next()){
// val id = rs.getInt(1)
// val name = rs.getString(2)
// val age = rs.getInt(3)
// println("学号:%d 姓名:%s 年龄:%d".format(id,name,age))
// }
// }
}
object MysqlDemo{
// def apply(): MysqlDemo = new MysqlDemo()
// def apply(driver:String,url:String,userName:String,password:String):MysqlDemo=new MysqlDemo(driver,url,userName,password)
def main(args: Array[String]): Unit = {
val demo = new MysqlDemo()
demo.insert(3,"zzz",18)
demo.select()
}
}
Scala数组集合函数大全
数组是可变的、可索引的数据集合
Array
val arr = Array(1,2,3,4)//声明数组对象
val first = arr(0) //读取第一个元素
arr(3) = 100 //替换第四个元素的值
val newArr = arr.map(_*2)//元素乘以2
val arr1 = arr.map(x=>x*2)
//打印数组
println(arr.mkString("*")) //1*2*3*4
prtintln(newArr.mkString("(",*,")")) (2*4*6*200)
++
合并集合，并返回一个新的数组，新数组包含左右两个集合的内容
val a = Array(1,2)
val b = Array(3,4)
val c = a ++ b
println(c.mkString("*")) //1*2*3*4
++:
这个方法同++方法类似，两个加号后面多了一个冒号，但是不同的是右边操纵数的类型决定着返回结果的类型
var a = List(1,2)
println(a.getClass.getName)//默认不可变
val b = scala.collection.mutable.LinkedList(3,4)
println(b.getClass.getName) //b是可变的
val c = a ++: b
println(c.getClass.getName) //c是可变的
val d = b ++: a
println(d.getClass.getName) //d是不可变的
+：
在数组前面添加一个元素，并返回新的数组对象
val a = List(1,2)
val ints = 0 +: a
println(ints.mkString(",")) //0,1,2
:+
在数组后面添加一个元素，并返回新的数组对象
val a = List(1,2)
val ints = a :+ 3
println(ints.mkString(",")) //1,2,3
/:
对数组中所有的元素从左向右遍历，进行相同的迭代操作
val a = Array(1,2,3,4)
val b = (10/:a)(_+_) // (((10+1)+2)+3)+4
println(b)
val c = (10/:a)((x,y)=>x+y)
println(c)
val d = (10/:a)((x,y)=>{println("x:"+x,"y:"+y);x+y})
:\
对数组中所有的元素从右向左遍历，进行相同的迭代操作
val a = Array(1,2,3,4)
val b = (a:\10)(_-_)
println(b)
val c = (a:\10)((x,y)=>x-y)
println(c)
val d = (a:\10)((x,y)=>{println("x:"+x,"y:"+y);x-y})
addString
将数组中的元素逐个添加到 StringBuilder 中
val a = List(1,2,3,4)
val b = new StringBuilder()
println(b.getClass.getName) //scala.collection.mutable.StringBuilder
a.addString(b)
println(b) //1234
addString(b,sep)
将数组中的元素逐个添加到 StringBuilder 中，每个元素用 sep 分隔符分开
val a = Array(1,2,3,4)
val b = new StringBuilder()
a.addString(b,",")
println(b) //1,2,3,4
aggregate
聚合计算，aggregate 是柯里化方法，参数是两个方法
def seqno(m:Int,n:Int):Int ={
val s="seq_op=%d + %d"
println(s.format(m,n))
m+n
}
def combine(m:Int,n:Int):Int ={
val s = "combine_op=%d + %d"
println(s.format(m,n))
m+n
}
val a = Array(1,2,3,4)
val i = a.aggregate(5)(seqno,combine)
println(i)
这里是不分区，只调用了seqno方法，初始值5作为入参只使用了一次后面开始累加 如图显示
分区（想看到多分区初始值不同的情况，可以将数组长度尽量长）
val i = a.par.aggregate(5)(seqno,combine)
pintln(i)
分成四个区，每分区一次，初始值作为入参使用一次
combine：将所有分区的结果进行组合，例如这里有四个分区，即有四个分区结果，按要求两两相加，再将得到的结果再相加
需求：List(Array(3,5,2,4),Array(7,8,1,2,9),Array(4,6,7))的平均值
//使用元组 初始值是元组
//(0,0) Array(3,5,2.4) - (14,4) 前者是和 后者是个数
//aggregate((0,0))在seqno中做初始化入参，每个分组使用一次
//combine 将每个分组相加 得到元组(所有值的和，总个数)
val aa = List(Array(3,5,2,4),Array(7,8,1,2,9),Array(4,6,7))
def seqno(m:(Int,Int),n:Array[Int]):(Int,Int)={
(m._1+n.sum,m._2+n.size)
}
def combine(m:(Int,Int),n:(Int,Int)):(Int,Int)={
(m._1+n._1,m._ 2+n._2)
}
val tuple =aa.par.aggregate((0,0))(seqno,combine)
println(tuple._1/tuple._2.toDouble)
520
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
