1.数组Array
1.1定长数组
1.1.1 定义方式
//通过new的方式
val arr1 = new Array [Int] (3) //指定长度为3。Int类型初始化为0
val arr2 = new Array [String] (3) //String类型初始化为null

//通过apply方法
val arr3 = Array(1,“scala”,3,14)
val arr4 = Array.apply(1,“scala”,3,14)
说明：apply方法内部通过new Array [T] ()

1.1.2 通过下标赋值、修改值
//定长数组赋值、修改
arr2(0) = “章子怡”
arr2(1) = “王菲”
arr2(1) = “鞠婧祎”
返回：ArrayBuffer(章子怡, 鞠婧祎, null)

1.1.3 数组转List
//数组转List
val list1: immutable.Seq[String] = arr2.toList
val list2: List[String] = arr2.toList

1.1.4 遍历数组元素
//通过下标取值
for (i <- 0 until arr3.length) {
println(s"i==i==i=={arr4(i)}")
}

//直接循环出数组元素
for (i <- arr4) {
println(i)
}

1.2变长数组
import scala.collection.mutable.{ArrayBuffer, ListBuffer} //依赖包
1.2.1定义方式
//通过new的方式
val buffer1 = new ArrayBuffer[String] ()
buffer1 += “王祖贤”
buffer1 += “林青霞”

//通过apply方法
val buffer2 = ArrayBuffer(“赵丽颖”,“鞠婧祎”)
val buffer3 = ArrayBuffer.apply(“李一桐”,“周迅”)

1.2.2 删除元素
buffer3.remove(1) //删除下标为1的元素

1.2.3 排序
//排序
val buffer4 = ArrayBuffer(1,3,5,7,6,4,2,0)
val buffer4_1 = buffer4.sortWith(<)
val buffer4_2 = buffer4.sortWith((x,y) => x < y)

2.集合Map
2.1不可变map
2.1.1定义方式
//通过-> 来定义Map或者元组方式
val map1:Map[String,Int] = Map(“鞠婧祎” -> 25, “刘亦菲” -> 31)
val map2 = Map((“杨钰莹”,44),(“邓丽君”,46))

2.1.2 遍历元素
for (i <- map1) {
println(i)
}

for ((k,v) <- map1) {
println(k,v)
}

//迭代循环
for (i <- map1.iterator) {
println(i)
}

//增强循环
map1.foreach(tuple => {
println(tuple._1,tuple._2)
})

2.1.3 取值
val keys = map1.keySet //获取所有key
val values = map1.values //获取所有value
val value1 = map1.getOrElse(“杨紫”,“无此值”) //获取对应key的value

2.2可变map
import scala.collection.{immutable, mutable} //依赖包
2.2.1 定义方式
val mmap = mutable.Map[String, String] () //需要指定泛型
val mmap2 = mutable.Map.empty[String, Int]
val hmap = mutable.HashMap[String,String] () //需要指定泛型
val hmap2 = mutable.HashMap.empty[String, Int]

2.2.2 添加元素
mmap += “杨幂” -> “女”
mmap += (“杨紫” -> “女”, “任嘉伦” -> “男”)
mmap += ((“刘亦菲”, “女”), (“胡歌”, “男”), (“涂磊”, “未知”),(“鞠婧祎”,“女”))

2.2.3 删除元素
mmap -= “刘亦菲”

2.2.4 修改元素
mmap.update(“涂磊”, “男”)

2.2.5 根据key获取值
hmap += ((“杨幂”,“三生三世十里桃花”),(“鞠婧祎”,“叹云夕”),(“胡歌”,“琅琊榜”),(“任嘉伦”,“白蛇传说”),(“杨紫”,“白蛇传说”))
val it: Iterable[String] = mmap.keys
var value: Option[String] = null
it.foreach(key => {
value = hmap.get(key) //一般使用getOrElse(“key值”,“默认值”)
value match {
case None => println(s"key==未主演电视剧")caseSome(otherValue)=>println(s"key==未主演电视剧") case Some(otherValue) => println(s"key==未主演电视剧")caseSome(otherValue)=>println(s"key==$otherValue")
}
})

说明：
默认创建的map为不可变的map， Map() immutable.Map()
如果创建可变的map必须要使用mutable；mutable.MapA,B
可变和不可变的区别：
a 定义使用的关键字不一样
b 不可变的map如果使用 val修饰，则不能修改其值，但是可变的map无论用var或者val修饰都可以修改其值
c 不可变的map在更新其值之后会返回一个新的map，但是可变的map修改其值将修改原map值，返回unit

3.列表List
3.1 不可变List
3.1.1 定义方式
val lis1 = List(“贾静雯”, “安以轩”, “杨幂”, “高圆圆”)

3.1.2 添加元素
val lis2 = lis1 :+ “黎姿” //末尾添加
val lis3 = “张敏” +: lis2 //列表头部添加

3.2 可变List
3.2.1 定义方式
val lbf1: ListBuffer[String] = new ListBuffer[String] ()
val list = mutable.ListBuffer.empty[String]
val list2 = mutable.ListBufferString

3.2.2 添加元素
lbf1 += “飞狐外传”
lbf1 += “雪山飞狐”
lbf2 += “连城诀”
lbf2 += “天龙八部”
lbf2.append(“射雕英雄传”)
lbf2.append(“白马啸西风”)

4.Set
//不可变Set
val set1: Set[String] = Set[String] () //特质，不能new。通过apply方法
val set2: Set[String] = new HashSet[String] () //new 其子类对象

//可变Set
val mset3: mutable.Set[String] = mutable.Set ()
val mset = mutable.Set.empty[String]
val hashSet = new mutable.HashSet[String] ()
val mhset = mutable.HashSet.empty[String]

hashSet += “笑傲江湖”
hashSet.add(“书剑恩仇录”)

5.for过滤器
5.1 函数
//for过滤器函数
val grepFunc = (books: ArrayBuffer[String], grepPattern: String) => {
if (books != null) {
val greps: ArrayBuffer[String] = for {
book <- books
if (book.contains(grepPattern))
} yield book
println(greps)
}
}

5.2 方法
//for过滤器方法
def grep(books: ArrayBuffer[String]): ArrayBuffer[String] = {
var greps: ArrayBuffer[String] = null
if (books != null) {
greps = for {
book <- books
if (book.length == 3)
} yield book
}
greps
}

5.3 测试
val buffer2 = ArrayBuffer[String] ()
buffer2 += (“武林外史”,“绝代双骄”,“楚留香传奇”,“多情剑客无情剑”,“萧十一郎”,“流星蝴蝶剑”,“边城浪子”,
“陆小凤传奇”,“孔雀翎”,“天涯明月刀”,“三少爷的剑”,“圆月弯刀”,“小李飞刀”,“浣花洗剑录”)

5.4 scala中的循环中断

package scalaDemoimport util.control.Breaks._object CircleBreak {def main(args: Array[String]): Unit = {//方式1：通过调用break函数实现中断var num1 = 0breakable {while (num1 <= 50) {if (num1 % 2 != 0) {println(s"num1==$num1")}if (num1 == 9) {println("while循环中断...\r\nfor循环开始...")break()}num1 += 1}}breakable {for (num2 <- 1 to 50) {if (num2 % 2 == 0) {println(s"num2==$num2")}if (num2 == 10) {println("for循环中断...\r\n")break()}}}//方式2：通过循环守卫实现中断var flag = true//def apply(start: Int, end: Int, step: Int): Range = new Range(start, end, step)for (num3 <- Range(1, 10, 2) if flag) {if (num3 == 5) {flag = falseprintln("结束循环...")} else {println(s"num3==$num3")}}//方式3：通过引入外部变量val arr = Array('a','b','c','d','e','f')var i = 0var elem = ' 'var tmpf = truewhile ({elem = arr(i); i <= arr.length && tmpf}) {if (elem != 'd') {println(elem)} else {println("结束循环...")tmpf = false}i +=1}}
}

5.5 scala中循环实现continue效果

package scalaDemoobject CircleContinue {def main(args: Array[String]): Unit = {//方式1：通过循环守卫实现continue效果for (i <- 1 to 10 if i % 2 == 0) {println(s"i==$i")}var j = 0while (j <= 10) {//方式2：通过if表达式实现continue效果if (j % 2 != 0) {println(s"j==$j")}j +=1}}
}

6.scala中的变长参数
//变长参数
def method1(author: String, books: String*): String = {
val buffer = new StringBuffer()
var res: String = “”
if (!author.isEmpty && books != null) {
buffer.append(author + “:”)
for (book <- books) {
buffer.append(book + “|”)
}
val tmpStr = buffer.toString
res = tmpStr.substring(0,tmpStr.length-1)
}
res
}
//测试
val res1 = method1(“古龙”,“武林外史”,“绝代双骄”,“楚留香传奇”,“多情剑客无情剑”,“萧十一郎”,“流星蝴蝶剑”,“边城浪子”)
println(res1)
备注：scala中的变长参数只允许有一个,且必须在末尾

7.类
7.1 内部类
class CircleArea {
private[this] var r: Double = _
private[this] var s: Double = _

def rget: Double = r

def rset(r: Double): Unit = {
this.r = r
}

//圆面积
def getCircleArea: Double = {
this.s = 3.14*Math.sqrt®
s
}

//圆柱体积(内部类可以访问外部类中的属性)
class CylinderVolume {
private[this] var h: Double = _
var v: Double = _ //外部类无法访问内部类中的属性

def hget: Double = hdef hset(h: Double): Unit = {this.h = h
}//体积
def getCylinderVolume: Double = {s*h
}

}

//获取内部类
def getInnerCylinderVolume: CylinderVolume = {
val cylinderVolume = new CylinderVolume
cylinderVolume
}
}

object CircleArea {
def main(args: Array[String]): Unit = {
val r: Double = 6
val h: Double = 1
val circleArea = new CircleArea
circleArea.rset®
val s = circleArea.getCircleArea
//内部类不能直接new,需要提供一个方法
val cylinderVolume = circleArea.getInnerCylinderVolume
cylinderVolume.hset(h)
val v = cylinderVolume.getCylinderVolume
println(s"r: $r\r\nh: $h\r\ns: $s\r\nv: $v")
}
}

7.2 主构造器
//主构造器参数用val修饰后,将不能再次赋值
class Demo3(var book: String, var author: String) {

def myMethod1(book: String, author: String): Unit = {
this.book = book
this.author = author
}

override def toString: String = s"书名: $book 作者: $author"
}

object TestMain {
def main(args: Array[String]): Unit = {
val demo1 = new Demo3(“射雕英雄传”,“金庸”)
println(demo1)
demo1.myMethod1(“楚留香传奇”,“古龙”)
println(demo1)
}
}

package scalaDemo.chapter.chapter02object Test_Variable {def main(args: Array[String]): Unit = {val stu1 = new Student01("赵敏", 20, "清华大学")//1.Student01对象中的name属性访问不到，没有用val或var修饰//2.由于age被val修饰，值不可修改。而school被var修饰，值可以修改// stu1.age = 18stu1.school = "北京大学"stu1.stuInfo/*** 总结：主构造器中name、age、school都会被编译成私有成员变量和构造方法* private final String name;* private final int age;* private String school;** public Student01(String name, int age, String school) {}** val修饰的变量会生成公有的类似java中的"get"方法* public int age() {*   return this.age;* }** val修饰的变量会生成公有的类似java中的"get"方法和 "set"方法* scala中用变量名()和变量名_$eq()来表示* public String school() {*   return this.school;* }** public void school_$eq(String x$1) {*     this.school = x$1;* }****/}
}class Student01(name: String, val age: Int, var school: String) {def stuInfo = {println(s"name=$name age=$age school=$school")}
}

7.3 辅助构造器

//主构造器private修饰,仅限于当前类、伴生对象访问;private[this]表示仅限于当前类访问
class Demo5 private (var author: String, var bookName: String) {
private var star: String = _
private[this] var fan: String = _ //关键字this,伴生对象无法访问该属性

//辅助构造器1
def this(author: String, bookName: String,star: String) = {
this(author,bookName) //调用主构造器
this.star = star
}

//辅助构造器2 (方式1)
// def this(author: String, bookName: String,star: String,fan: String) = {
// this(author,bookName)
// this.star = star
// this.fan = fan
// }

//辅助构造器2 (方式2)
def this(author: String, bookName: String,star: String,fan: String) = {
this(author,bookName,star) //调用辅助构造器1
this.fan = fan
}

override def toString: String = {
s"author: $author\r\nbookName: $bookName\r\nstar: $star\r\nfan: $fan"
}
}

object Demo5 {
def main(args: Array[String]): Unit = {
//主构造器创建对象
val demo1 = new Demo5(“古龙”,“小李飞刀”)
//辅助构造1器创建对象
val demo2 = new Demo5(“古龙”,“小李飞刀”,“萧蔷”)
//辅助构造器2创建对象
val demo3 = new Demo5(“古龙”,“小李飞刀”,“萧蔷”,“高晓松”)

println(demo1)
println(demo2)
println(demo3)

}
}

7.4 自定义apply方法

//主构造器private修饰,仅限于当前类、伴生对象访问;private[this]表示仅限于当前类访问
class Demo6 private (var author: String, var bookName: String) {
private var star: String = _
private[this] var fan: String = _ //关键字this,伴生对象无法访问该属性

//辅助构造器1
def this(author: String, bookName: String,star: String) = {
this(author,bookName) //调用主构造器
this.star = star
}

//辅助构造器2 (方式1)
// def this(author: String, bookName: String,star: String,fan: String) = {
// this(author,bookName)
// this.star = star
// this.fan = fan
// }

//辅助构造器2 (方式2)
def this(author: String, bookName: String,star: String,fan: String) = {
this(author,bookName,star) //调用辅助构造器1
this.fan = fan
}

override def toString: String = {
s"author: $author\r\nbookName: $bookName\r\nstar: $star\r\nfan: $fan"
}
}

//自定义apply方法
object Demo6 {
//定长参数
def apply(author: String, bookName: String): Demo6 = {
val demo = new Demo6(author,bookName)
demo
}

//定长参数
def apply(author: String, bookName: String, star: String): Demo6 = {
val demo = new Demo6(author,bookName,star)
demo
}

//变长参数
def apply(author: String, str: String*): Demo6 = {
var demo: Demo6 = null
if (!str.isEmpty && str != null) {
demo = new Demo6(author,str(0),str(1),str(2))
}
demo
}
}

object Demo6Test {
def main(args: Array[String]): Unit = {
Array(1,2)
val demo1 = Demo6(“古龙”,“小李飞刀”)
val demo2 = Demo6(“古龙”,“小李飞刀”,“萧蔷”)
val demo3 = Demo6(“古龙”,“小李飞刀”,“萧蔷”,“高晓松”)

println(demo1)
println(demo2)
println(demo3)

}
}

7.5 setter和getter方法

package scalaDemoobject ClassTest {def main(args: Array[String]): Unit = {val person = new Person()person.name = "鞠婧祎"  //person.name_$eq("鞠婧祎")person.gender = "女" //person.gender_$eq("女")// person.age = 26   //person.age_$eq(26)}
}
class Person {private val privateDescription: String = "私有属性-人类" //生成的字节码文件中，只有私有的getter方法--pirvate String privateDescription()val publicDescription: String = "公有属性-动物" //生成的字节码文件中，只有公有的getter方法--public String publicDescription()var name: String = _  //var修饰的变量，编译成的字节码文件中，既有setter方法又有getter方法
protected var gender1: String = _ //当前类及其子类对象可以访问
protected[scalaDemo] var gender2: String = _ //String和引用类型的变量，使用"_"初始化时全部为nullprivate var age: Int = _  //val修饰的属性，字节码文件只有getter方法，而var修饰的属性，字节码文件既有setter又有getter方法
}
/*
public class Person {private final String privateDescription = ";private String privateDescription() {return this.privateDescription;}private final String publicDescription = ";private String name;private String gender;private int age;public String publicDescription() {return this.publicDescription;}public String name() {return this.name;}public void name_$eq(String x$1) {this.name = x$1;}public String gender() {return this.gender;}public void gender_$eq(String x$1) {this.gender = x$1;}private int age() {return this.age;}private void age_$eq(int x$1) {this.age = x$1;}
}
*/

class Demo4 {
private val reader: String = “张韶涵”
private var bookName: String = _ //当前类及其伴生对象可以访问
private[this] var author: String = _ //this表示只能在当前类中访问，伴生对象无法访问

//getter方法和setter方法
def bookname: String = bookName

def bookname_=(bookName: String): Unit = {
this.bookName = bookName
}

def authors: String = author

def authors_=(author: String): Unit = {
this.author = author
}
}

object Demo4Test {
def main(args: Array[String]): Unit = {
val class1 = new Demo4
class1.bookname_=(“西游记”)
class1.authors_=(“吴承恩”)
println(class1.bookname)
println(class1.authors)

}
}
说明：
1.scala中是没有getter和setter说法的，当成员变量用private、private[this]等修饰时，
可以提供一对方法，如：method、method_=来替代getter、setter方法

7.6 继承及多态
import scala.collection.mutable.ArrayBuffer
import scala.util.Random

abstract class Animals {
var name: String = _
var age: Int = _
var sex: String = _

def action: String
}

class Persion extends Animals {

private var university: String = _

def this(name: String, age: Int, sex: String) = {
this()
this.name = name
this.age = age
this.sex = sex
}

def this(name: String, age: Int, sex: String, university: String) = {
this(name, age, sex)
this.university = university
}

override def action: String = {
s"name: $nameage: $agesex: $sexuniversity: $universityaction: 喜欢看书、玩游戏、恋爱…"
}

override def toString: String = {
s"name: $nameage: $agesex: $sex**university: $university"
}
}

class Dog extends Animals {
private var food: String = _

def this(name: String, age: Int, sex: String) = {
this()
this.name = name
this.age = age
this.sex = sex
}

def this(name: String, age: Int, sex: String, food: String) = {
this(name, age, sex)
this.food = food
}

override def action: String = {
s"name: $nameage: $agesex: $sexfood: $foodaction: 喜欢卖萌、奔跑、啃骨头…"
}

override def toString: String = s"name: $nameage: $agesex: $sex**food: $food"
}

class Bird extends Animals {
private var flyHigh: Double = _

def this(name: String, age: Int, sex: String) = {
this()
this.name = name
this.age = age
this.sex = sex
}

def this(name: String, age: Int, sex: String, flyHigh: Double) = {
this(name, age, sex)
this.flyHigh = flyHigh
}

override def action: String = {
s"name: $nameage: $agesex: $sexflyHigh: $flyHighaction: 喜欢翱翔、高飞、叽叽喳喳…"
}

override def toString: String = s"name: $nameage: $agesex: $sex**flyHigh: $flyHigh"
}

object ExtendsDemo {
def main(args: Array[String]): Unit = {
val persion: Animals = new Persion(“人类”, 100, “female”, “清华大学”)
val dog = new Dog(“狗类”, 10, “male”, “骨头”)
val bird = new Bird(“鸟类”, 6, “female”, 999)
val buffer: ArrayBuffer[Animals] = new ArrayBuffer
buffer += (persion, dog, bird)
println(buffer)
//多态。父类引用指向子类对象
val animals: Animals = buffer(Random.nextInt(buffer.length))
println(animalAction(animals))
}

//定义一个方法
def animalAction(animal: Animals): String = {
animal.action //实际调用子类中的方法
}
}

7.7 类型判断和类型转换
import scala.collection.mutable.ListBuffer
import scala.util.Random

abstract class Animal {
var name: String = _
var age: Int = _

def action: String
}

class Persion2(var sex: String) extends Animal {
private var favoriteStar: String = _

def this(name: String,age: Int,sex: String) = {
this(sex)
this.name = name
this.age = age
}

def this(name: String,age: Int,sex: String,favoriteStar: String) = {
this(name,age,sex)
this.favoriteStar = favoriteStar
}

def persionMethod: Unit = {
println(“Persion类：”+this.getClass)
}

override def action: String = s"喜欢看书、玩游戏、恋爱…"

override def toString = s"姓名：name∣年龄：name|年龄：name∣年龄：age|性别：sex∣最喜欢的明星：sex|最喜欢的明星：sex∣最喜欢的明星：favoriteStar"
}

class Bird2(var sex: String) extends Animal {
var flyHigh: Double = _

def this(name: String,age: Int,sex: String) = {
this(sex)
this.name = name
this.age = age
}

def this(name: String,age: Int,sex: String,flyHigh: Double) = {
this(name,age,sex)
this.flyHigh = flyHigh
}

def birdMethod: Unit = {
println(“Bird类：”+this.getClass)
}

override def action: String = s"喜欢翱翔、高飞、叽叽喳喳…"

override def toString = s"姓名：name∣年龄：name|年龄：name∣年龄：age|性别：sex∣飞翔高度：sex|飞翔高度：sex∣飞翔高度：flyHigh"
}

object ExtendsDemo2 {
def main(args: Array[String]): Unit = {
val persion = new Persion2(“郭敬明”,30,“male”,“杨幂”)
val bird = new Bird2(“白鹭”,2,“female”,999)

val buffer: ListBuffer[Animal] = new ListBuffer[Animal]
buffer += (persion,bird)
println(buffer)
println(classOf[Persion2])
println(classOf[Bird2])instanceOfMethod1(buffer(Random.nextInt(buffer.length)))
instanceOfMethod2(buffer(Random.nextInt(buffer.length)))

}

//判断一个类是否为指定类及其子类对象。该方法不能精确判断
def instanceOfMethod1(animal: Animal) = {
if(animal.isInstanceOf[Persion2]) {
val persion = animal.asInstanceOf[Persion2]
persion.persionMethod
} else if (animal.isInstanceOf[Bird2]) {
val bird = animal.asInstanceOf[Bird2]
bird.birdMethod
} else {
println(“其他类型”)
}
}
//可以精确判断
def instanceOfMethod2(animal: Animal) = {
if (animal.getClass == classOf[Persion2]) {
val persion = animal.asInstanceOf[Persion2]
persion.persionMethod
} else if (animal.getClass == classOf[Bird2]) {
val bird = animal.asInstanceOf[Bird2]
bird.birdMethod
} else {
println(“其他类型”)
}
}
}

7.8 样例类
case class Teacher(name: String, age: Int)

case class Student(name: String, age: Int)

object Stranger

object CaseClassTest {
def main(args: Array[String]): Unit = {
val teacher1 = Teacher(“张三”,33)
val teacher2 = Teacher(“李四”,26)

val student1 = Student("小明",9)
val student2 = Student("小红",19)val stranger1 = Strangerval arr = Array(teacher1,teacher2,student1,student2,stranger1)for (person <- arr) {println(matchCase(person))
}

}

def matchCase(person: AnyRef) = {
person match {
case Teacher(name,age) => s"name=name∣age=name|age=name∣age=age 允许教师进入…"
case Student(name,age) => {
if (age < 18)
s"name=name∣age=name|age=name∣age=age 允许未成年学生进入…"
else
s"name=name∣age=name|age=name∣age=age 允许成年学生进入…"
}
case Stranger => s"禁止陌生人进入!!!"
case _ => s"错误类型匹配!!!"
}
}
}
说明：
case类是一种特殊的类，它们经过优化以被用于模式匹配
当定义一个类时，如果在class关键字前加上case关键字，则该类称为case类
Scala为case类自动重载了许多实用的方法，包括toString、equals和hashcode方法
Scala为每一个case类自动生成一个伴生对象，其包括模板代码1个apply方法，因此，实例化case类的时候无需使用new关键字。和1个unapply方法，该方法包括一个类型为伴生类的参数返回的结果是Option类型，对应的类型参数是N元组，N是伴生类中主构造器参数的个数。Unapply方法用于对对象进行解构操作，在case类模式匹配中，该方法被自动调用，并将待匹配的对象作为参数传递给它。

7.9 特质
trait UsbDisk {
var usbDiskType: String

def usbFunc: String
}

trait Mouse {
var mouseType: String

def mouseFunc: String
}

abstract class Computer {
var brand: String
var price: String
var madeIn: String

def permitGames: String
}

class ThinkPad(var optionSystem: String) extends Computer with UsbDisk with Mouse {

override var brand: String = _
override var price: String = _
override var madeIn: String = _
override var usbDiskType: String = _
override var mouseType: String = _

def this(brand: String,price: String,madeIn: String,os: String) = {
this(os)
this.brand = brand
this.price = price
this.madeIn = madeIn
this.optionSystem = os
}

def this(brand: String,price: String,madeIn: String,os: String,usbDiskType: String) = {
this(brand,price,madeIn,os)
this.usbDiskType = usbDiskType
}

def this(brand: String,price: String,madeIn: String,os: String,usbDiskType: String,mouseType: String) = {
this(brand,price,madeIn,os,usbDiskType)
this.mouseType = mouseType
}

override def permitGames: String = s"绝地求生、英雄联盟、炉石传说…"

override def usbFunc: String = s"U盘用来备份游戏数据…"

override def mouseFunc: String = s"鼠标用来操作人物的移动方向…"

override def toString: String = s"[{电脑|品牌：brand,产地：brand, 产地：brand,产地：madeIn, 操作系统：optionSystem,价格：optionSystem, 价格：optionSystem,价格：price},{U盘|类型：KaTeX parse error: Expected 'EOF', got '}' at position 12: usbDiskType}̲,{鼠标|类型：mouseType}]"
}

object ExtendsDemo3 {
def main(args: Array[String]): Unit = {
val computer1 = new ThinkPad(“thinkPadE480”,“6666RMB”,“China”,“Win10”)
val computer2 = new ThinkPad(“thinkPadE480”,“6666RMB”,“China”,“Win10”,“西部数据”,“罗技”)
println(computer1)
println(computer2)
println(computer2.permitGames)
println(computer2.usbFunc)
println(computer2.mouseFunc)
}
}
说明：
定义关键字trait。特质类似于java中的接口，java中实现接口关键字"implements"，scala中使用"with"，如class A extends classB with traitC with traitD …

7.10 抽象类

package scalaDemo.abstractDemo.Demo01abstract class Animal01 {var name: String //抽象属性var sex: Stringval name2 = "Animal01" //普通属性def describ(): String  //抽象方法def action()  //抽象方法/*** @Author: qwerdf@QAQ* @Description:* 总结：* 抽象类不能被实例化，可以通过创建匿名子类对象来实现* 抽象类不一定有abstract方法，但是含有抽象方法或抽象属性的一定是抽象类* scala中抽象方法不能用abstract标记，定义方式：def temp()* 如果一个类继承了抽象类，则必须实现抽象类的所以抽象方法和抽象属性，除非它自己也声明为abstract类* 抽象方法和抽象属性不能使用private、final来修饰，因为这些关键字都是和重写/实现相违背的* 抽象类可以有实现的方法* 子类重写抽象方法不需要override，也可以加上* @Date: 2021/3/14* @Param null:* @return: null**/}package scalaDemo.abstractDemo.Demo01object AnimalTest01 {def main(args: Array[String]): Unit = {//临时创建一个匿名子类val dog = new Animal01 {override var name: String = "dog"override var sex: String = "雌性"override def describ(): String = {s"name: $name\nsex: $sex"}override def action(): Unit = {println("正在追赶小偷...")}}val cat = new Animal01 {override var name: String = "cat"override var sex: String = "雄性"override def describ(): String = {s"name: $name\nsex: $sex"}override def action(): Unit = {println("正在抓老鼠...")}}println(dog.describ())dog.action()println(cat.describ())cat.action()}}

8.方法和函数
import scala.collection.mutable
import scala.collection.mutable.{ArrayBuffer, ListBuffer}

object FuncAndMethod {
def main(args: Array[String]): Unit = {
//定义一个函数
val fun1: (Int,Int) => Int = (x,y) => x + y
val fun2 = (x:Int, y:Int) => x + y
val fun2_2 = (x: Int) => x //入参只有一个时，括号不能少
val fun3: () => String = () => “飞雪连天射白鹿”

println(fun3()) //参数列表为空时,调用fun3()括号不能省略
method5(999999999) //方法中参数列表为空可以省略括号method2("笑书神侠倚碧鸳")val hmap = new mutable.HashMap[String,ArrayBuffer[String]]()
val buffer1 = ArrayBuffer[String]()
val buffer2 = ArrayBuffer[String]()
buffer1 += "飞狐外传"
buffer1 += "飞狐外传"
buffer1 += "雪山飞狐"
buffer1 += "连城诀"
buffer1 += "天龙八部"
buffer1 += "射雕英雄传"
buffer1 += "白马啸西风"
buffer1 += "鹿鼎记"
buffer1 += "笑傲江湖"
buffer1 += "书剑恩仇录"
buffer1 += "神雕侠侣"
buffer1 += "侠客行"
buffer1 += "倚天剑"
buffer1 += "碧血剑"
buffer1 += "鸳鸯刀"
buffer2 += ("武林外史","绝代双骄","楚留香传奇","多情剑客无情剑","萧十一郎","流星蝴蝶剑","边城浪子","陆小凤传奇","孔雀翎","天涯明月刀","三少爷的剑","圆月弯刀","小李飞刀","浣花洗剑录")
hmap += ("金庸" -> buffer1,("古龙",buffer2))
println(hmap)val res1 = method3("神雕侠侣",hmap)
val res2 = method3("流星蝴蝶剑",hmap)
val res3 = method3("三国演义",hmap)
println(res1)
println(res2)
println(res3)val res4 = method4("小李飞刀",hmap,fun4)
val res5 = method4("神雕侠侣",hmap,fun4)
val res6 = method4("西游记",hmap,fun4)
println(res4)
println(res5)
println(res6)val grep1: ArrayBuffer[String] = grep(buffer1)
println(grep1)//for过滤器函数
val grepFunc = (books: ArrayBuffer[String], grepPattern: String) => {if (books != null) {val greps: ArrayBuffer[String] = for {book <- booksif (book.contains(grepPattern))} yield bookprintln(greps)}
}grepFunc(buffer1,"剑")

}

//for过滤器方法
def grep(books: ArrayBuffer[String]): ArrayBuffer[String] = {
var greps: ArrayBuffer[String] = null
if (books != null) {
greps = for {
book <- books
if (book.length == 3)
} yield book
}
greps
}

//定义一个方法
def method1(x:Int,y:Int): Int = {
x + y
}

def method2(str: String): Unit = {
if (!str.isEmpty && str != null) {
println(str)
}
}

def method3(bookName: String, bookStore: mutable.Map[String,ArrayBuffer[String]]): String = {
var tmp_author: String = “未知作者”
if (!bookName.isEmpty || bookName != null) {
for (map <- bookStore) {
val author = map._1
val bookArray = map._2
if (bookArray.contains(bookName)) {
tmp_author=author
}
}
}
tmp_author
}

def method4(bookName: String, bookStore: mutable.Map[String,ArrayBuffer[String]],fun: (String, mutable.Map[String,ArrayBuffer[String]]) => String) : String = {
val value = fun(bookName,bookStore)
value
}

val fun4: (String,mutable.Map[String,ArrayBuffer[String]]) => String = (bookName,bookStore) => {
var tmp_author: String = “未知作者”
if (!bookName.isEmpty || bookName != null) {
for (map <- bookStore) {
val author = map._1
val bookArray = map._2
if (bookArray.contains(bookName)) {
tmp_author=author
}
}
}
tmp_author
}

def method5(f: => Int) = {
println(f)
}
}

9.偏函数
object PartialFunc {
def main(args: Array[String]): Unit = {
val array = Array(‘a’,5,2f,1314D,false,“偏函数”)
for (arr <- array) {
println(matchCase(arr))
println(partitionFunc(arr))
}
}

def matchCase(element: Any) = {
element match {
case a: Char => s"char类型a"casea:Int=>s"int类型a" case a: Int => s"int类型a"casea:Int=>s"int类型a"
case a: Long => s"Long类型a"casea:Float=>s"float类型a" case a: Float => s"float类型a"casea:Float=>s"float类型a"
case a: Double => s"double类型a"casea:Boolean=>s"布尔类型a" case a: Boolean => s"布尔类型a"casea:Boolean=>s"布尔类型a"
case b: String => s"string类型$b"
case _ => s"未匹配到…"
}
}

//偏函数定义
def partitionFunc: PartialFunction[Any, String] = {
case a: Char => s"char类型a"casea:Int=>s"int类型a" case a: Int => s"int类型a"casea:Int=>s"int类型a"
case a: Long => s"Long类型a"casea:Float=>s"float类型a" case a: Float => s"float类型a"casea:Float=>s"float类型a"
case a: Double => s"double类型a"casea:Boolean=>s"布尔类型a" case a: Boolean => s"布尔类型a"casea:Boolean=>s"布尔类型a"
case b: String => s"string类型$b"
case _ => s"未匹配到…"
}
}
说明：
没有match匹配的一组case语句，常用于输入模式匹配。
PartialFunction[A,B] —A表示输入类型,B表示输出类型

10.泛型(方法、类)
abstract class Persion4 {
var name: String
var age: Int

def work: Unit
}

class Teacher4(var salary: Double) extends Persion4 {
override var name: String = _
override var age: Int = _

def this(salary: Double, name: String, age: Int) = {
this(salary)
this.name = name
this.age = age
}

override def work: Unit = println(“教书育人…”)

def getTeacherInfo: String = {
s"姓名：name年龄：name 年龄：name年龄：age 工资：$salary"
}

override def toString = s"Teacher($name, $age, $salary)"
}

//类添加泛型
class Student4[T] (var chineseScore: T, var mathScore: T, var englishScore: T, var comprehensiveScore: T) extends Persion4 {
override var name: String = _
override var age: Int = _

def this(name: String, age: Int, chinese: T, math: T, english: T, comprehensive: T) = {
this(chinese,math,english,comprehensive)
this.name = name
this.age = age
}

override def work: Unit = println(“遨游知识的海洋,为中华崛起而奋斗…”)

def getStudentInfo: String = {
s"姓名：name年龄：name 年龄：name年龄：age 成绩：[chineseScore,chineseScore,chineseScore,mathScore,englishScore,englishScore,englishScore,comprehensiveScore]"
}

override def toString = s"Student($name, $age, chineseScore,chineseScore,chineseScore,mathScore,englishScore,englishScore,englishScore,comprehensiveScore)"
}

object GenericType {
def main(args: Array[String]): Unit = {
val student1 = new Student4Int
val teacher1 = new Teacher4(6666D,“小马哥”,27)

val arr = Array(student1,teacher1)for (per <- arr) {val info = getInfo(per)println(info)
}

}

//方法添加泛型
def getInfo[T](persion: T): String = {
if (persion.getClass == classOf[Student4[Int]]) {
val student = persion.asInstanceOf[Student4[Int]]
student.getStudentInfo
} else if (persion.getClass == classOf[Teacher4]) {
val teacher = persion.asInstanceOf[Teacher4]
teacher.getTeacherInfo
} else s"其他类型…"
}
}

11.上边界和下边界
abstract class ElecGoods {
var categary: String
var brand: String
var model: String

def function: String
}

class Pad extends ElecGoods {
var madeIn: String = _
override var categary: String = _
override var brand: String = _
override var model: String = _

def this(madeIn: String, categary: String, brand: String, model: String) = {
this()
this.categary = categary
this.brand = brand
this.model = model
this.madeIn = madeIn
}

override def function: String = {
s"电影、听音乐、玩游戏…"
}

override def toString = s"Phone($categary, $brand, $model, $madeIn)"
}

class Phone extends ElecGoods {
var madeIn: String = _
override var categary: String = _
override var brand: String = _
override var model: String = _

def this(madeIn: String, categary: String, brand: String, model: String) = {
this()
this.categary = categary
this.brand = brand
this.model = model
}

override def function: String = {
s"通话、听音乐、玩游戏…"
}

override def toString = s"Phone($categary, $brand, $model, $madeIn)"
}

class HuaWeiPhone(var detailModel: String) extends Phone {
private var price: Double = _

def this(categary: String, brand: String, model: String, madeIn: String, detailModel: String) = {
this(detailModel)
this.categary = categary
this.brand = brand
this.model = model
this.madeIn = madeIn
}

def this(categary: String, brand: String, model: String, madeIn: String, detailModel: String, price: Double) = {
this(categary,brand,model,madeIn,detailModel)
this.price = price
}

override def toString = s"HuaWeiPhone($categary, $brand, $model, $madeIn, $detailModel, $price)"
}

class Iphone(var detailModel: String) extends Phone {
private var price: Double = _

def this(categary: String, brand: String, model: String, madeIn: String, detailModel: String) = {
this(detailModel)
this.categary = categary
this.brand = brand
this.model = model
this.madeIn = madeIn
}

def this(categary: String, brand: String, model: String, madeIn: String, detailModel: String, price: Double) = {
this(categary,brand,model,madeIn,detailModel)
this.price = price
}

override def toString = s"Iphone($categary, $brand, $model, $madeIn, $detailModel, $price)"
}

object BoundType {
def main(args: Array[String]): Unit = {
val pad = new Pad(“USA”,“平板电脑”,“苹果”,“ipad”)
val phone = new Phone(“China”,“5G手机”,“华为”,“Mate30”)
val huaWeiPhone = new HuaWeiPhone(“5G手机”,“华为”,“Mate30”,“China”,“Mate30_Pro_8G”,6399)
val iphone = new Iphone(“5G手机”,“苹果”,“iphoneSE”,“USA”,“iphoneSE2_4G”,2799)

upBoundMethod[Phone](huaWeiPhone)
upBoundMethod[Phone](iphone)
//upBoundMethod[Phone](pad)   //编译提示：方法入参类型不匹配,应该为泛型Phone的类型或者子类
//upBoundMethod[ElecGoods](phone) //泛型错误，当前上边界值为Phone类型，泛型A应该为Phone类、HuaWeiPhone类、Iphone类downBoundMethod[Phone](huaWeiPhone)
downBoundMethod[Phone](iphone)

// downBoundMethodPhone //编译提示：方法入参类型不匹配,应该为泛型Phone的类型或者子类
downBoundMethodHuaWeiPhone //泛型错误,当前下边界值为Phone类型,泛型B应该为Phone类、ElecGoods类
}

//上边界 A类型为Phone类及其子类，而该方法入参类型为A类型及其A类型的子类对象
def upBoundMethod [A <: Phone] (elecGoods: A): Unit = {
if (elecGoods.getClass == classOf[HuaWeiPhone]) {
val huaWeiPhone = elecGoods.asInstanceOf[HuaWeiPhone]
println(huaWeiPhone)
} else if (elecGoods.getClass == classOf[Iphone]) {
val iphone = elecGoods.asInstanceOf[Iphone]
println(iphone)
}
}

//下边界 B类型为Phone类及其父类，而该方法入参类型为B类型及其B类型的子类对象,因为B类型的子类不仅仅只有Phone一个
def downBoundMethod[B >: Phone](elecGoods: B): Unit = {
if (elecGoods.isInstanceOf[Phone]) {
val phone = elecGoods.asInstanceOf[Phone]
println(phone)
}
}

}

12.隐式转换之参数、方法、类
12.1隐式参数

package scalaDemo.implicitDemo.demo01object ImplicitValDemo01 {implicit val name = "tom"implicit val age = 18def main(args: Array[String]): Unit = {implicitFun01implicitFun02("sunny")implicitFun03//运行报错}def implicitFun01(implicit name: String = "jack") = {println(s"fun01:my name is $name")}def implicitFun02(implicit name: String = "jack") = {println(s"fun01:my name is $name")}def implicitFun03(implicit score: Double) = {println(s"fun01:my score is $score")}/*** @Author: qwerdf@QAQ* @Description:* 总结：*      1.隐式值优先级：传值 > 隐式值 > 默认值*      2.隐式值匹配时不能有二义性*      3.如果调用方法时，传值、隐式值、默认值都没有，程序会报错* @Date: 2021/3/14* @Param null:* @return: null**/}

12.2隐式方法
object ImplictTransformationFunc {
def main(args: Array[String]): Unit = {
import CurrencyTypeTransformArea._
val rmb = new RMB()
//寻找隐式区域，调用隐式方法并将rmb作为参数传入获取CurrencyType对象，即currencyTypeTransform(rmb).toRMB

val rmbInfo = rmb.toRMB(520)
println(rmbInfo)val dollar = new Dollar()
val dollarInfo = dollar.toDollar(520)
println(dollarInfo)

}
}

//隐式区域
object CurrencyTypeTransformArea {
implicit def currencyTypeTransform(currencyType: Currency): CurrencyType = {
new CurrencyType
}
}

class CurrencyType {
def toRMB(price: Double): RMB = {
RMB(price)
}

def toDollar(price: Double): Dollar = {
Dollar(price)
}
}

class Currency {}

class RMB extends Currency {
var price: Double = _
private val logo: String = “RMB”

def this(price: Double) = {
this()
this.price = price
}

override def toString = s"pricepricepricelogo"
}

object RMB {
def apply(price: Double): RMB = new RMB(price)
}

class Dollar extends Currency {
var price: Double = _
private val logo: String = “$”

def this(price: Double) = {
this()
this.price = price
}

override def toString = s"pricepricepricelogo"
}

object Dollar {
def apply(price: Double): Dollar = new Dollar(price)
}

12.3隐式类

package scalaDemo.implicitDemo.demo02object ImplicitClassDemo01 {implicit class DataBaseFun01(val mySql: Mysql) {def insert(): String = {s"insert..."}}def main(args: Array[String]): Unit = {val mysql = new Mysqlprintln(mysql.insert())}
}class Mysql {val dname: String = "mysql"def dbState = {s"mysql is running..."}/*** @Author: qwerdf@QAQ* @Description:* 总结：*     1.隐式类的构造参数有且只能有一个*     2.隐式类必须定义在类、伴生对象、包对象里面，不能是顶级的objects*     3.隐式类不能是case class*     4.作用域内不能有同名标识符，否则编译器无法识别* @Date: 2021/3/14* @Param null:* @return: null**/}

需要一个主构造器,且参数只能有一个；
隐式类必须定义在类或伴生对象中…
object ImplictTransformationFunc {
//隐式类
implicit class CurrencyType2(var currency: Currency) {
def toRMB(price: Double): RMB = {
RMB(price)
}

def toDollar(price: Double): Dollar = {Dollar(price)
}

}

def main(args: Array[String]): Unit = {
//方式1：隐式方法测试
// import CurrencyTypeTransformArea._ //导入隐式方法区域
// val rmb = new RMB()
// //寻找隐式区域，调用隐式方法并将rmb作为参数传入获取CurrencyType对象，即currencyTypeTransform(rmb).toRMB
// val rmbInfo = rmb.toRMB(520)
// println(rmbInfo)

//方式2：隐式类测试
val dollar = new Dollar()
//寻找隐式类,然后将dollar作为构造器参数进行实例化,即CurrencyType2(dollar).toDollar
val dollarInfo = dollar.toDollar(1314)
println(dollarInfo)

}
}

//隐式区域
object CurrencyTypeTransformArea {
implicit def currencyTypeTransform(currencyType: Currency): CurrencyType = {
new CurrencyType
}
}

class CurrencyType {
def toRMB(price: Double): RMB = {
RMB(price)
}

def toDollar(price: Double): Dollar = {
Dollar(price)
}
}

class Currency {}

class RMB extends Currency {
var price: Double = _
private val logo: String = “RMB”

def this(price: Double) = {
this()
this.price = price
}

override def toString = s"pricepricepricelogo"
}

object RMB {
def apply(price: Double): RMB = new RMB(price)
}

class Dollar extends Currency {
var price: Double = _
private val logo: String = “$”

def this(price: Double) = {
this()
this.price = price
}

override def toString = s"pricepricepricelogo"
}

object Dollar {
def apply(price: Double): Dollar = new Dollar(price)
}

隐式转换场景：
当方法中的参数类型与目标类型不一致时候，如：
def method1(age: Int) = {}
method1(66.5) //传入类型不匹配，要想编译通过,可使用隐式转换。
当对象调用所在类中没有该方法或成员时，编译器会自动将对象进行隐式转换，转变为含有该方法或成员的实例。

13.Unit、Null、Nothing类型
13.1 Null类
Null类只有一个实例对象null,类似于java中的null引用，null可以赋值给任意引用类型AnyRef,但是不能赋值给值类型AnyVal
13.2 Unit类
Unit类型用来标识过程，也就是没用明确返回值的函数，类似于java里的void。Unit类只有一个实例()，没有实质意义。
def sayOk(): Unit = {
println(“ok”)
}
13.3 Nothing类
Nothing类可以作为没有正常返回值的方法的返回类型，非常直观的告诉你这个方法不会正常返回。该类是其他任意类型的子类，可以跟要求返回值的方法兼容。
def test() : Nothing = {
throw new Exception()
}

14.递归

package scalaDemoobject Fibnacci {def main(args: Array[String]): Unit = {println(fibn(7))}/*** @Author: qwerdf@QAQ* @Description: 斐波那契数列数列从第3项开始，每一项都等于前两项之和* 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597 ...* 示例： n=7 输出13* 第1次入栈：main栈  println(fibn(7))    最后输出：13* 第2次    fibn1栈  fibn(7)    fibn(n - 2) + fibn(n - 1)  返回9：5 + 8 = 13* 第3次    fibn(n - 2)  = fibn(5)    返回值8： 5*          fibn(n - 1) = fibn(6)    返回值7： 8* 第4次    fibn(5 - 2) + fibn(5 - 1) = fibn(3) + fibn(4)  返回值6：2+3=5*          fibn(6 - 2) + fibn(6 - 1) = fibn(4) + fibn(5) 返回值5：3+5=8* 第5次    f(1) + f(2) = 2*          f(2) + f(3) = 1 + f(3)   返回值4：1+2=3*          f(2) + f(3) = 1 + f(3)   返回值3：1+2=3*          f(3) + f(4)    返回值1：2+3=5*第6次     f(1) + f(2) = 2*          f(1) + f(2) = 2*          f(1) + f(2) = 2*          f(2) + f(3) = 1 + f(3)   返回值1：1+2=3*第7次     f(1) + f(2) = 2**备注：先入栈则后出栈** @Date: 2022/4/23* @Param null:* @return: null**///递归函数编译阶段无法推断具体的结果类型，必须指定返回值类型val fibn: Int => Int = n => {if (n == 1 || n == 2) {1} else {fibn(n - 2) + fibn(n - 1)}}
}

15.异常处理

package scalaDemo
import com.sun.xml.internal.bind.v2.TODOobject TryCatch {def main(args: Array[String]): Unit = {/*** @Author: qwerdf@QAQ* @Description: 将可能发生异常的代码封装在try块中，catch块用来捕获异常并处理，避免程序异常中止*              1.在scala中只有一个catch，在java中可以有多个*              2.在catch中有多个case，每个case匹配一种异常，即模式匹配思想。* @Date: 2022/4/24* @Param args:* @return: void**/try {val num = 9 / 0} catch {case ex: ArithmeticException => {//TODO  捕获异常，处理业务逻辑println("捕获了除数为零的算术异常")}case ex: Exception => {//TODO  捕获异常，处理业务逻辑println("捕获了异常")}} finally {//TODO 有无异常都会执行的代码块，一般用于关闭数据库连接、IO流等println("执行finally代码块...")}println("程序继续执行...")}
}

编程语言之scala基础相关推荐

1. （数据科学学习手札45）Scala基础知识

   一.简介 由于Spark主要是由Scala编写的,虽然Python和R也各自有对Spark的支撑包,但支持程度远不及Scala,所以要想更好的学习Spark,就必须熟练掌握Scala编程语言,Scal ...

2. 23篇大数据系列（二）scala基础知识全集（史上最全，建议收藏）

   作者简介: 蓝桥签约作者.大数据&Python领域优质创作者.管理多个大数据技术群,帮助大学生就业和初级程序员解决工作难题. 我的使命与愿景:持续稳定输出,赋能中国技术社区蓬勃发展! 大数据系 ...

3. scala基础（一）

   Scala 编程 -Scala基础 1.课程目标 安装Scala编译和运行环境 熟悉Scala基本语法以及函数式编程 熟练掌握Scala数据结构使用以及集合方法操作 2.Scala基础 2.1Scal ...

4. 【Spark】scala基础入门

   文章目录 零.IDEA的scala环境配置 0.1 spark和scala之间的关系 0.2 编写项目 (0)创建项目 (1)配置pom.xml文件: (2)配置对应环境 (3)测试代码 (4)控制台 ...

5. 【一天一门编程语言】Scala 语言程序设计极简教程

   Scala 语言程序设计极简教程 用 markdown 格式输出答案. 不少于3000字.细分到2级目录. 目录 简介 基本语法 变量 数据类型 运算符 流程控制 函数 类 应用 安装 环境搭建 编程 ...

6. Scala基础教程（一）：简介、环境安装

   Scala基础语法 如果有很好的了解Java语言,那么将很容易学习Scala. Scala和Java间的最大语法的区别在于;行结束符是可选的.考虑Scala程序它可以被定义为通过调用彼此方法进行通信的 ...

7. Scala 基础（8）—— 占位符_和部分应用函数

   1. 占位符 _ 针对 Scala 基础(7)-- 函数字面量和一等函数 中最后提到的,关于 filter 函数字面量的精简写法,可以使用占位符 _ 来代替. 占位符_,用来表示一个或者多个参数.(这 ...

8. Scala学习(一)--Scala基础学习

   Scala基础学习 摘要: 在篇主要内容:如何把Scala当做工业级的便携计算器使用,如何用Scala处理数字以及其他算术操作.在这个过程中,我们将介绍一系列重要的Scala概念和惯用法.同时你还将学 ...

9. Scala基础教程--10--数组列表与函数式编程

   Scala基础教程–10–数组列表与函数式编程 章节目标 掌握数组, 元组相关知识点 掌握列表, 集, 映射相关知识点 了解迭代器的用法 掌握函数式编程相关知识点 掌握学生成绩单案例 1. 数组 1. ...

最新文章

1. 反射拷贝对象的思路:
2. 西南民族大学计算机基础技能应用培训基地,计科学院第九期Office应用培训开班典礼顺利举办...
3. 神秘使者到 Java 帝国传道协程，竟被轰了出去！
4. layui table行点击tr_layui框架table表格实现单击行选中checkbox功能
5. mongodb存储二进制数据的二种方式——binary bson或gridfs
6. ITK:向量值图像像素的变换幅度
7. Jenkins构建自动化任务
8. log日志java web_Javaweb项目中使用Log4j记录日志
9. office 论文 页码_还在花钱找人排版？这份最全攻略，让你论文一次过！
10. ”炮灰“团队自主开发，未参考任何Ftp搜索引擎代码，留个纪念。
11. 知了课堂项目part1
12. 使用nginx时候html页面乱码解决办法
13. 51/STC12单片机SCON,PCON,TMOD寄存器定义及功能
14. svn 冲突 Error:Node remains in conflict
15. 【新学期新FLAG】一名计科新生の大一学习计划
16. nginx 日志问题(\x22)
17. ChatGPT使用和无法登录，拒绝访问的问题汇总
18. 「kd指标」kd指标原理
19. 视图优化oracle,干货｜Oracle复杂视图优化案例分析
20. 五、JQuery制作页面导航

热门文章

1. 我的世界服务器显示无法解析主机名什么意思,我开了我的世界服务器可为什么它出现无法解析主机名...
2. 二进制文件操作-存储与读取
3. 一种文件捆绑型病毒研究
4. Wechaty 李卓桓：我想要某种功能，你没有？那我来一个
5. 计算机应用基础自学手写笔记,计算机应用基础第一章笔记.docx
6. Win7电池电量设置
7. zynq--实现udp发送helloworld 到上位机---续集，调试时候容易出现有时候系统不响应
8. OCP 11G 051题库解析汇总链接
9. ht城市介绍人口数量Html,城市人口热力图 城市热力图查询
10. IAR Embedded Workbench调试技七