package com.song.scala.day3
object test01_1 {
def main(args: Array[String]): Unit = {
//創建一個元組，獲取元組中值，遍歷元組
val tup=(1,2,3,4,5,6)
for (i<-tup.productIterator){
// println(i)
}
//集合裏有多個數組，每個數組的長度相同，將每個數據在相同下標下的元素進行聚合
//例如：Seq(Array(2,3,4),Array(3,4,5),Array(4,5,6))
//結果爲Array(7,10,13)
val seq=Seq(Array(2,3,4),Array(3,4,5),Array(4,5,6))
val res = seq.reduce((x, y) => (x zip y).map(x => x._1 + x._2))
//數組 拉起來就是小的元組了
println(res.toBuffer)
}
}
package com.song.scala.day3
/**
* 構造器
* 主構造器的聲明方式，在類後面加參數列表
* 主構造器的參數列表可以放多個參數，這些參數往往作爲初始化
* val 修飾的不可以改變 var 修飾可以後期改變
* faceValue並沒有修飾符默認val 不可改變
*
* faceValue構造參數只能在本類訪問，伴生對象也無法訪問
*
*/
class StructDemo(val name: String, var age: Int, faceValue: Int = 60) {
var gender: String = _
var adress:String=_
//使用方法獲取faceValue
def getFV: Int = faceValue
//輔助構造器,可以引入主構造器的部分字段
def this(name: String, age: Int, gender: String) {
//輔助構造器裏第一行代碼必須先調用主構造器的字段
this(name, age)
this.gender = gender
}
}
object StructDemo {
def main(args: Array[String]): Unit = {
// val hauhua: StructDemo = new StructDemo("hauhua", 14)
// println(hauhua.name)
//使用方法獲取
// println(hauhua.getFV)
//使用輔助構造器創建對象
val huahuaa = new StructDemo("huahuaa", 14, "man")
println(huahuaa)
}
}
package com.song.scala.day3
import scala.collection.mutable.ArrayBuffer
/*
單例對象不能給實例
在創建對象的實例時，不用new
在實例化單例對象時，裏面的對象會賦值
*/
object SingletonDemo {
def main(args: Array[String]): Unit = {
//單例對象不用new
val s = SessionFactory
println(s.getSession.size)
println(s.getSession)
s.removeSession()
}
}
//單例對象 ：用object修飾的爲單例對象
object SessionFactory {
println("SessionFactory")
var i = 4 //計數器，用來創建對象
//用於存放session對象的變長數組
val sessions = new ArrayBuffer[Session]()
//循環創建多個對象
while (i > 0) {
println("while被執行")
sessions.append(new Session)
i -= 1
}
//提供獲取session對象的方法
def getSession: ArrayBuffer[Session] = sessions
//刪除session對象的方法
def removeSession(): Unit = {
val session = sessions(0)
sessions.remove(0)
println("session對象被移除---->" + session)
}
}
class Session {
}
package com.song.scala.day3
/**
* 類名和類文件名稱可以不統一
* 一個類文件可以有多個類
* 聲明一個類，不用加public等關鍵字，默認就是public
*/
class Person {
//用var修飾字段相當於只有get方法，也有set方法
var id: Int = _
var name: String = _
//用var修飾字段相當於只有get方法，沒有有set方法
val address: String = "huilongguan"
//該字段前面加private.稱爲私有字段，只能在本類和其伴生對象中訪問
private var age: Int = _
//private [this] 修飾的對象稱爲私有對象，只能在本類訪問，伴生對象也不可以
private [this] val gender="mal"
//如果我們想訪問對象私有字段，一般我們會聲明一個獲取私有字段的方法
def getGender: String=gender
}
//object修飾的是單例對象,伴生對象只能有一個
//一個類的伴生對象和他的主類相同，並且用obeject修飾
object Person {
def main(args: Array[String]): Unit = {
val p = new Person
println(p.id)
println(p.name)
p.age = 12
println(p.age)
println(p.getGender)
}
}
class PersonTest {
}
package com.song.scala.day3
/**
*一個主類的伴生對象
* 單例對象包含伴生對象
* 主類和他的伴生對象之間可以互相訪問私有字段和屬性
*
*/
class ComapaionObject {
var id = 0
private val name = "tingjie"
def printContent(): Unit = {
println(name + ComapaionObject.content)
}
}
object ComapaionObject {
private val content = "is my goddess"
def main(args: Array[String]): Unit = {
val co = new ComapaionObject
println(co.id)
println(co.name)
co.printContent()
}
}
package com.song.scala.day3
/**
* apply方法只能聲明在主類的伴生對象中
* apply方法通常被稱爲注入方法
* 用途：經常用apply方法做一些初始化的操作
* apply方法的參數列表和主類構造器參數可以不統一
* unapply方法通常稱爲提取方法，使用unapply方法可以提取固定數量的值或者對象
* unapply方法會返回一個option對象，如果Option有值，會返回一個some對象，如果沒有值返回一個null方法
*/
class ApplyDemo(val name: String, val age: Int, val faceValue: Int = 60) {
}
object ApplyDemo {
//注入方法
def apply(name: String, age: Int): ApplyDemo = {
new ApplyDemo(name, age)
}
//提取方法
def unapply(applyDemo: ApplyDemo): Option[(String, Int, Int)] = {
if (applyDemo == null) {
None
} else {
Some(applyDemo.name, applyDemo.age, applyDemo.faceValue)
}
}
}
object ApplyTest {
def main(args: Array[String]): Unit = {
//調用apply
val applyDemo = ApplyDemo("xiaoli", 20)
//調用unapply
applyDemo match {
case ApplyDemo(name,age,faceValue)=>println(s"name: $name")
case _=>println("no match nothing")
}
}
}
package com.song.scala.day3
object ClassDemo {
def main(args: Array[String]): Unit = {
}
}
/*
特質:trait
*/
trait Flyable{
//有值的字段
val distance: Int=100
//沒有值的字段
val hight:Int
//有方法體的方法
def fly:String="i can fly"
//沒有方法體的方法
def fight: String
}
/**
* 抽象類
*/
abstract class Animal{
//有值的字段
val age:Int=19
val name:String
//有方法體的方法
def climb:String="I can climb"
//沒有方法體的方法
def run
}
//實現用with
// ,在沒有繼承父類的情況下，如果需要實現trait,此時的關鍵字爲extends
// ,在沒有父類的情況下 關鍵字爲with
class Human extends Animal with Flyable {
override val name: String = "dazhao"
//重寫有方法體的方法
override def climb: String = "i can not climb"
override def run: Unit = "i can run"
//沒有值的字段
override val hight: Int = 2
//實現沒有方法體的方法
override def fight: String = "fight with bar"
}
package com.song.scala.day3.mathchdemo
object MatchArray extends App{
//匹配數組
val arr=Array(3,4,5,6,7)
arr match {
case Array(3,a,d,v,e) =>println("case 1")
case Array(3,_*) =>println("case 2")
case Array(_*) =>println("nothing")
}
//匹配元組
val tuple1=(3,4,5,6)
tuple1 match {
case (3,a,v,b)=> println("caseq")
case (_,a,v,b)=> println("case3")
case _=> println("caseq")
}
//匹配集合
val list=List(3,4,5,6)
list match {
case 1::nil::Nil=>println("case1")
}
}
package com.song.scala.day3.mathchdemo
import scala.util.Random
class MatchClass {
}
object MatchClass extends App {
val matchClass = new MatchClass
var arr=Array("tingjie",34,true,matchClass)
val ele=arr(Random.nextInt(arr.length))
println(ele)
ele match {
case str :String => println("match strinh")
case int:Int=>println("match Int")
case _ =>println("aaa")
}
}
package com.song.scala.day3.mathchdemo
import scala.util.Random
object MatchString {
def main(args: Array[String]): Unit = {
val arr=Array("anqila","daji","yangzi","gaungaun ")
val name=arr(Random.nextInt(arr.length))
println(name)
name match{
case "anqila" => println("安其拉")
case "daji" => println("妲己")
case "yangzi" => println("楊子")
case "gaungaun" => println("anqila")
}
}
}
樣例類
在scala中樣例類是一種特殊的類，樣例類是不可變的
可以通過值進行比較可用於模式匹配
定義一個樣例類：
1.構造器中每一個參數都是val,除非顯示地聲明爲var
2.伴生對象提供apply 讓你不使用new 關鍵字就能構造出相應的對象
case class Point(x:Int,y:Int)
package com.song.scala.day3.mathchdemo
import sun.plugin2.message.HeartbeatMessage
import scala.util.Random
/**
* 樣例類就是用case class聲明的類
* 樣例類 可以分爲case object 和case class
* 其中case object是沒有構造參數的，case class是可以放構造參數的
* 樣例類的作用：
* 1.和模式匹配搭配使用，使得代碼更加靈活
* 2.樣例類case class 可以封裝多個值到樣例類，也就是封裝的效果
*/
object CaseClassDemo {
def main(args: Array[String]): Unit = {
var arr=Array(CheckTimeOutworker,SubmitTask("001","task_001"),HeatBeat(10000))
arr(Random.nextInt(arr.length)) match {
case CheckTimeOutworker => println("outWorker ")
case SubmitTask(id,taskName) => println("submit ")
case HeatBeat(time) => println("HeatBeat")
case _ => println("nothing")
}
}
}
case object CheckTimeOutworker {
def apply: Any = ???
}
/**
* 開發中將樣例類放到單獨的類文件中
* @param id
* @param taskName
*/
case class SubmitTask(id:String,taskName:String)
case class HeatBeat(time:Long)
Option類型
在scala中Option類型樣例用來表示可能存在或者可能不存在的值（Option的子類有some和none）some包裝了某個值，None表示沒有值
package com.song.scala.day3.mathchdemo
/**
* some類型可以封裝多類型的數據，Some的父類是Option
*/
object OptionDemo {
def main(args: Array[String]): Unit = {
// val seq: Some[(String, Int, Boolean)] = Some("huahua",12,true)
// val value: (String, Int, Boolean) = seq.getOrElse(null)
// println(value)
}
}
偏函數
被包在花括號內沒有match的一組case語句是一個偏函數，他是PartialFunction[a,b]的一個實例，A代表參數類型，B代表返回類型，常用作輸入模式匹配
一個是apply方法，直接調用可以通過體內的case進行匹配，返回結果
另一個是isDefinedAt()方法，可以返回一個輸入，是否跟任何一個case匹配s
package com.song.scala.day3.mathchdemo
/**
* 偏函數輸入模式匹配的一種
*/
object PartticalFunc {
def main(args: Array[String]): Unit = {
println(m1("one"))
println(m2("one"))
}
def m1(num: String): Int = num match {
case "one" => 1
case "two" => 2
case _ => -1
}
/**
*
* @return
*/
def m2: PartialFunction[String, Int] = {
case "one"=> {
println("case one")
1
}
case "two"=>{
println(" case two")
}
2
}
}
scala的輸入輸出
導入scala.io.Source後，即可引用Source中的方法讀取文件信息
source.*
高階函數(方法加下劃線 可以將方法轉換爲函數)