【
使用场景:
打开数据库连接
由于表达式执行代价昂贵, 因此我们希望能推迟该操作, 直到我们确实需要表达式结果值时才执行它
提升某些特定模块的启动时间.
为了缩短模块的启动时间, 可以将当前不需要的某些工作推迟执行
确保对象中的某些字段能优先初始化
为了确保对象中的某些字段能优先初始化, 我们需要对其他字段进行惰性化处理
】
-----------
package dheima.p1
/**
* ClassName: ${ClassName}
* Package: ${Package}
* Description:
*
* @Author: ZhangQiang1
* @Date: 2021/9/9 9:10
* @Version: 1.0
*/
object Biyan3StudentGrade {
def main(args: Array[String]):Unit = {
// 1. 定义列表, 记录学生的成绩, 格式为: 姓名, 语文成绩, 数学成绩, 英语成绩, 学生信息如下: ("张三",37,90,100),
//("李四",90,73,81), ("王五",60,90,76), ("赵六",59,21,72), ("田七",100,100,100)
val stuList=List(("张三",37,90,100),("李四",90,73,81),("王五",60,90,76),("赵六",59,21,72),("田七",100,100,100))
//2. 获取所有语文成绩在60分(含)及以上的同学信息.
val chineseList=stuList.filter(_._2>=60)
// println(s"语文成绩及格的学生信息: ${chineseList}")
//3. 获取所有学生的总成绩. //用的元组
val countList=stuList.map(x=> x._1->(x._2+x._3+x._4))
// println(countList)
//4. 按照总成绩降序排列. //一般是升序 站在列表上来看
// val rankList=countList.sortBy(_._2).reverse
val sortList2=countList.sortWith((x,y) => x._2 > y._2)
// println(rankList)
// println(sortList2)
//5. 打印结果.
println(s"语文成绩合格的学生信息：${chineseList}")
println(s"所有学生及其总成绩：${countList}")
println(s"总成绩降序排列：${sortList2}")
}
}
语文成绩合格的学生信息：List((李四,90,73,81), (王五,60,90,76), (田七,100,100,100))
所有学生及其总成绩：List((张三,227), (李四,244), (王五,226), (赵六,152), (田七,300))
总成绩降序排列：List((田七,300), (李四,244), (张三,227), (王五,226), (赵六,152))
刺激：
玩了一个简写形式的
package dheima.p1
import scala.io.StdIn
/**
* ClassName: ${ClassName}
* Package: ${Package}
* Description:
*
* @Author: ZhangQiang1
* @Date: 2021/9/9 9:59
* @Version: 1.0
*/
object biYan4pipei {
def main(args: Array[String]):Unit = {
println("请您输入单词：")
val word=StdIn.readLine()
wordmatch {
case "hadoop" =>println("大数据分布式存储和计算框架")
case "zookeeper" =>println("大数据分布式协调服务框架")
case "spark" =>println("大数据分布式内存计算框架")
case _ =>println("未匹配")
}
}
}
需求 1. 提示用户录入一个单词并接收.
2. 判断该单词是否能够匹配以下单词，如果能匹配，返回一句话
3. 3. 打印结果.
单词 返回
hadoop 大数据分布式存储和计算框架
zookeeper 大数据分布式协调服务框架
spark 大数据分布式内存计算框架
未匹配 未匹配
package dheima.p1
/**
* ClassName: ${ClassName}
* Package: ${Package}
* Description:
*
* @Author: ZhangQiang1
* @Date: 2021/9/9 10:09
* @Version: 1.0
*/
object biyan5leixingPipei {
def main(args: Array[String]):Unit = {
// var word:Any="hadoop"
var word:Any=1.0
wordmatch {
case word1:String =>println("String类型")
case word1:Int =>println("Int型")
case word1:Double =>println("Double型")
case _ =>println("未匹配")
}
}
}
测了个寂寞：
你怎么这么好看
package dheima.p1
/**
* ClassName: ${ClassName}
* Package: ${Package}
* Description:
*
* @Author: ZhangQiang1
* @Date: 2021/9/9 10:09
* @Version: 1.0
*/
object biyan5leixingPipei {
def main(args: Array[String]):Unit = {
//1. 定义一个变量为Any类型，然后分别给其赋值为"hadoop"、1、1.0
val a:Any =1
//2. 定义模式匹配，然后分别打印类型的名称
val result = amatch {
case x:String =>s"${x}是String类型的数据"
case x:Double =>s"${x}是Double类型的数据"
case x:Int =>s"${x}是Int类型的数据"
case _ =>"未匹配"
}
//3. 打印结果
println(result)
}
}
【需求：
需求 1. 从控制台读入一个数字a（使用StdIn.readInt）
如果 a >= 0 而且 a <= 3，打印[0-3]
如果 a >= 4 而且 a <= 8，打印[4,8]
否则，打印未匹配
代码：
package dheima.p1
import scala.io.StdIn
/**
* ClassName: ${ClassName}
* Package: ${Package}
* Description:
*
* @Author: ZhangQiang1
* @Date: 2021/9/9 10:46
* @Version: 1.0
*/
object biyan6ShouWei {
def main(args: Array[String]):Unit = {
//需求 1. 从控制台读入一个数字a（使用StdIn.readInt）
println("请输入数据：")
val num=StdIn.readInt()
//2. 如果 a >= 0 而且 a <= 3，打印[0-3]
nummatch {
case aif(a >=0 &&a <=3)=>println("[0-3]")
case aif(a >=4 &&a <=8)=>println("[4,8]")
case _ =>println("未匹配")
}
//3. 如果 a >= 4 而且 a <= 8，打印[4,8]
// 4. 否则，打印未匹配
}
}
】
打了个寂寞：
package dheima.p1
/**
* ClassName: ${ClassName}
* Package: ${Package}
* Description:
*
* @Author: ZhangQiang1
* @Date: 2021/9/9 10:54
* @Version: 1.0
*/
object biyan7yangLiLei {
def main(args: Array[String]):Unit = {
//需求
//1. 创建两个样例类Customer(包含姓名, 年龄字段), Order(包含id字段)
val customer1:Any=new Customer("alice",18)
val order1:Any=new Order("a345ce")
//2. 分别定义两个样例类的对象，并指定为Any类型
//3. 使用模式匹配这两个对象，并分别打印它们的成员变量值
/*val result= customer1 match {
case Customer(name,age) => s"姓名：${name},年龄：${age}"
case Order(id:String) =>s"id: ${id}"
case _ => "未匹配"
}
println(result)*/
val result2= order1match {
case Customer(name,age) =>s"姓名：${name},年龄：${age}"
case Order(id:String) =>s"id: ${id}"
case _ =>"未匹配"
}
println(result2)
}
case class Customer(var name:String,var age:Int)
case class Order(var id:String)
}
需求 将的好
\1. 依次修改代码定义以下三个数组
Array(1,x,y) // 以1开头，后续的两个元素不固定
Array(0) // 只匹配一个0元素的元素
Array(0, ...) // 可以任意数量，但是以0开头
--------
package dheima.p1
/**
* ClassName: ${ClassName}
* Package: ${Package}
* Description:
*
* @Author: ZhangQiang1
* @Date: 2021/9/9 11:13
* @Version: 1.0
*/
object biyan8PipeiSHuzu {
def main(args: Array[String]):Unit = {
// \1. 依次修改代码定义以下三个数组
val arr1:Array[Any]=Array(1,2,"yhiuy")
val arr2:Array[Any]=Array(0)
val arr3:Array[Any]=Array(0,5,8,6)
arr1match {
case Array(1,x,y) =>println(s"元素长度为3，以1开头，后面两个元素为：${x}和${y}")
case Array(0) =>println("匹配：只有一个0元素的数组")
case Array(1,_*) =>println("匹配：起始为1，后面还有无数个元素的数组")
case _ =>println("未匹配")
}
// Array(1,x,y) // 以1开头，后续的两个元素不固定
// Array(0) // 只匹配一个0元素的元素
//
// Array(0, ...) // 可以任意数量，但是以0开头
}
}
结果：元素长度为3，以1开头，后面两个元素为：2和yhiuy
---
需求：
.5.2 示例二: 匹配列表 需求 1. 依次修改代码定义以下三个列表
List(0) // 只保存0一个元素的列表
List(0,...) // 以0开头的列表，数量不固定
List(x,y) // 只包含两个元素的列表
package dheima.p1
/**
* ClassName: ${ClassName}
* Package: ${Package}
* Description:
*
* @Author: ZhangQiang1
* @Date: 2021/9/9 11:13
* @Version: 1.0
*/
object biyan8PipeiSHuzu {
def main(args: Array[String]):Unit = {
// \1. 依次修改代码定义以下三个列表
val list1=List(1,2)
val list2=List(0)
val list3=List(0,5,8,6)
list1match {
case List(x,y) =>println(s"只包含两个元素的列表，两个元素为：${x}和${y}")
case List(0) =>println("匹配：只有一个0元素的列表")
case List(0,_*) =>println("匹配：起始为0，后面还有无数个元素的列表")
case _ =>println("未匹配")
}
}
}
//思路二: 采用关键字优化 Nil, tail
package dheima.p1
/**
* ClassName: ${ClassName}
* Package: ${Package}
* Description:
*
* @Author: ZhangQiang1
* @Date: 2021/9/9 11:13
* @Version: 1.0
*/
object biyan8PipeiSHuzu {
def main(args: Array[String]):Unit = {
// \1. 依次修改代码定义以下三个列表
val list1=List(1,2)
val list2=List(0)
val list3=List(0,5,8,6)
list3match {
case x::y::Nil =>println(s"只包含两个元素的列表，两个元素为：${x}和${y}")
case 0::Nil =>println("匹配：只有一个0元素的列表")
case 0::tail =>println("匹配：起始为0，后面还有无数个元素的列表")
case _ =>println("未匹配")
}
}
}
1.5.3 案例三: 匹配元组
需求
package dheima.p1
/**
* ClassName: ${ClassName}
* Package: ${Package}
* Description:
*
* @Author: ZhangQiang1
* @Date: 2021/9/9 11:13
* @Version: 1.0
*/
object biyan8PipeiSHuzu {
def main(args: Array[String]):Unit = {
// \1. 依次修改代码定义以下三个列表
val list1=(1,2,3)
val list3=(6,0,5)
list1match {
case (1,x,y) =>println(s"以1开头的、一共三个元素的元组 ，后两个元素为：${x}和${y}")
case (x,y,5) =>println("匹配： 一共有三个元素，最后一个元素为5的元组")
// case 0::tail => println("匹配：起始为0，后面还有无数个元素的列表")
case _ =>println("未匹配")
}
}
}
需求 1. 生成包含0-10数字的数组，使用模式匹配分别获取第二个、第三个、第四个元素
2. 生成包含0-10数字的列表，使用模式匹配分别获取第一个、第二个元素
打一波;
(1,2,3)
---------------
[object biyan9bianliang {
def main(args: Array[String]):Unit = {
//1. 生成包含0-10数字的数组，使用模式匹配分别获取第二个、第三个、第四个元素
//1.1 生成包含0-10数字的数组
val arr = (0 to10).toArray
//1.2 使用模式匹配分别获取第二个、第三个、第四个元素
val Array(_, x, y, z, _*) = arr;
//1.3 打印结果.
println(x, y, z)
println("-" *15)
}
----------
package dheima.p1
/**
* ClassName: ${ClassName}
* Package: ${Package}
* Description:
*
* @Author: ZhangQiang1
* @Date: 2021/9/9 11:41
* @Version: 1.0
*/
object biyan9bianliang {
def main(args: Array[String]):Unit = {
//1. 生成包含0-10数字的数组，使用模式匹配分别获取第二个、第三个、第四个元素
//1.1 生成包含0-10数字的数组
val list = (0 to10).toList
//1.2 使用模式匹配分别获取第二个、第三个、第四个元素
val List( x, y, _*) = list
//思路二: ::, tail 实现.
val c :: d ::tail = list
//1.3 打印结果.
println(x, y)
println(c,d)
println("-" *15)
}
}
讲得好
1.7 匹配for表达式 Scala中还可以使用模式匹配来匹配for表达式，从而实现快速获取指定数据, 让我们的代码看起来更简洁, 更优雅. 需求
定义变量记录学生的姓名和年龄, 例如: "张三" -> 23, "李四" -> 24, "王五" -> 23, "赵六" -> 26
2. 获取所有年龄为23的学生信息, 并打印结果.
张三=23
王五=23
---------------
张三=23
王五=23
daima代码：
package dheima.p1
/**
* ClassName: ${ClassName}
* Package: ${Package}
* Description:
*
* @Author: ZhangQiang1
* @Date: 2021/9/9 11:41
* @Version: 1.0
*/
object biyan9bianliang {
def main(args: Array[String]):Unit = {
// 讲得好
//
// 1.7 匹配for表达式 Scala中还可以使用模式匹配来匹配for表达式，从而实现快速获取指定数据, 让我们的代码看起来更简洁, 更优雅. 需求
//
// 1. 定义变量记录学生的姓名和年龄, 例如: "张三" -> 23, "李四" -> 24, "王五" -> 23, "赵六" -> 26
// 2. 2. 获取所有年龄为23的学生信息, 并打印结果.
var word=Map("张三" ->23, "李四" ->24, "王五" ->23, "赵六" ->26)
for((k,v) <- wordif v==23)println(s"${k}=${v}")
println("-"*15)
//2.2 格式二: 通过固定值实现.
for ((k,23) <- word)println(s"${k}=23")
}
}
package dheima.p1
/**
* ClassName: ${ClassName}
* Package: ${Package}
* Description:
*
* @Author: ZhangQiang1
* @Date: 2021/9/9 14:19
* @Version: 1.0
*/
object biyan10chuling {
def main(args: Array[String]):Unit = {
// 1. 定义一个两个数相除的方法，使用Option类型来封装结果
//2. 打印结果
//不是除零，打印结果
//除零, 则打印异常错误
val result=div(10,1)
//思路一.通过模式匹配来打印结果
resultmatch {
////不是除零，打印结果
case Some(x) =>println(x)
// //除零, 则打印异常错误
case None =>println("除数不能为0")
}
println("-"*15)
//思路二: 采用getOrElse()方法实现.
println(result.getOrElse(0))
}
def div(a:Int,b:Int)={
if (b==0){
None//除数为0，没有结果
}else {
Some(a/b)//除数不为0.返回具体的结果
}
}
}
package dheima.p1
/**
* ClassName: ${ClassName}
* Package: ${Package}
* Description:
*
* @Author: ZhangQiang1
* @Date: 2021/9/9 14:19
* @Version: 1.0
*/
object biyan10chuling {
def main(args: Array[String]):Unit = {
//
val word:PartialFunction[Int,String] ={
case 1 =>"一"
case 2 =>"二"
case 3 =>"三"
case _ =>"其他"
}
println(word(1))
println(word(2))
println(word(3))
println(word(4))
}
}
需求
1. 定义一个列表，包含1-10的数字
2. 请将1-3的数字都转换为[1-3]
3. 请将4-8的数字都转换为[4-8]
4. 将其他的数字转换为(8-*]
5. 打印结果.
简单解法;
val pf:PartialFunction[Int,String]={
case xif(x<4) =>"[1-3]"
case xif(x<9&&x>=4) =>"[4-8]"
case _ =>"(8-*]"
}
println(pf(5))
youd有点狂躁
package dheima.p2
/**
* ClassName: ${ClassName}
* Package: ${Package}
* Description:
*
* @Author: ZhangQiang1
* @Date: 2021/9/9 16:01
* @Version: 1.0
*/
object biyan1DefineGju {
class Person{
var name =""
var age =0
}
//1. 在main方法中创建Person类对象，设置成员变量为"张三"、23
def main(args: Array[String]):Unit = {
val p=new Person
p.name="张三"
p.age=23
//2. 打印对象的名字和年龄
println(p.name,p.age)
}
}
这种风格更搭配;
package dheima.p2
/**
* ClassName: ${ClassName}
* Package: ${Package}
* Description:
*
* @Author: ZhangQiang1
* @Date: 2021/9/9 16:01
* @Version: 1.0
*/
object biyan1DefineGju {
class Person{
var name:String =_
var age:Int =_
}
//1. 在main方法中创建Person类对象，设置成员变量为"张三"、23
def main(args: Array[String]):Unit = {
val p=new Person
p.name="张三"
p.age=23
//2. 打印对象的名字和年龄
println(p.name,p.age)
}
}
讲得好
package dheima.p2
/**
* ClassName: ${ClassName}
* Package: ${Package}
* Description:
*
* @Author: ZhangQiang1
* @Date: 2021/9/9 16:01
* @Version: 1.0
*/
object biyan1DefineGju {
class Customer{
var name:String=_
var sex:String=_
def printHello(msg:String){println(msg+",hello")}
}
//1. 在main方法中创建Person类对象，设置成员变量为"张三"、23
def main(args: Array[String]):Unit = {
val p=new Customer
p.name="zhangf"
p.sex="男"
println(p.name,p.sex)
p.printHello("chongchong")
}
}
(zhangf,男)
chongchong,hello
张宇
[
需求
编写一个DateUtils工具类专门用来格式化日期时间
定义一个方法，用于将日期（Date）转换为年月日字符串，例如：2030-10-05
定义一个方法, 用于将年月日字符串转换为日期(Date).
步骤
定义一个DateUtils单例对象
在DateUtils中定义日期格式化方法（date2String）和解析字符串方法(string2Date)
使用SimpleDateFormat来实现String和Date之间的相互转换
//案例: 定义DateUtils工具类, 用于实现String和Date之间的相互转换.
object ClassDemo15 {
//1. 定义DateUtils工具类. //也就是Scala中的单例对象.
object DateUtils {
//2. 创建SimpleDateFormat类型的对象, 用来进行转换操作.
var sdf: SimpleDateFormat = null
//3. 定义方法date2String, 用来将Date日期对象转换成String类型的日期.
//参数1: 日期对象, 参数2: 模板
def date2String(date: Date, template: String):String = {
sdf = new SimpleDateFormat(template)
sdf.format(date)
}
//4. 定义方法string2Date, 用于将String类型的日期转换成Date日期对象.
def string2Date(dateString: String, template: String) = {
sdf = new SimpleDateFormat(template)
sdf.parse(dateString)
}
}
//定义main方法, 作为程序的主入口.
def main(args: Array[String]): Unit = {
//5. 调用DateUtils#date2String()方法, 用来格式化日期.
val s = DateUtils.date2String(new Date(), "yyyy-MM-dd")
println("格式化日期: " + s)
//6. 调用DateUtils#string2Date()方法, 用来解析日期字符串.
val d = DateUtils.string2Date("1314年5月21日", "yyyy年MM月dd日")
println("解析字符串: " + d)
}
}
zui最简版
1. 定义抽象动物类(Animal), 属性: 姓名, 年龄, 行为: 跑步, 吃饭.
2. 定义猫类(Cat)继承自动物类, 重写吃饭的方法, 并定义该类独有的抓老鼠的方法.
3. 定义狗类(Dog)继承自动物类, 重写吃饭的方法, 并定义该类独有的看家的方法.
package dheima.p2
/**
* ClassName: ${ClassName}
* Package: ${Package}
* Description:
*
* @Author: ZhangQiang1
* @Date: 2021/9/9 17:19
* @Version: 1.0
*/
object biyan2dongwulei {
class Animal{
var name=""
var age=0
def eat(){}
def run()=println("动物会跑步!...")
}
class Catextends Animal{
override def eat():Unit = {
println("猫吃鱼")
}
def CatchMouse():Unit ={
println("猫抓老鼠")
}
}
def main(args: Array[String]):Unit = {
val p =new Cat
p.name="Alice"
p.age=18
p.eat()
p.CatchMouse()
}
}
最简单的 继承trait
package dheima.p2
/**
* ClassName: ${ClassName}
* Package: ${Package}
* Description:
*
* @Author: ZhangQiang1
* @Date: 2021/9/9 17:48
* @Version: 1.0
*/
object biyan3traitTest {
//1. 定义一个特质
trait Logger{
def log(msg:String)
}
//2. 定义一个类, 继承特质.
class Conggerextends Logger{
override def log(msg:String):Unit =println(msg)
}
def main(args: Array[String]):Unit = {
val c1=new Congger
c1.log("trait入门: 类继承单个特质")
}
}