那人独钓寒江雪

def main(args: Array[String]): Unit = { val list = List(1, 2, 3, 4, 5, 6, 7, 8, 9) //1.过滤 //选取偶数 println(list.filter(_ % 2 ==0))//选取满足条件的偶数 println(list.filter(_ % 2 !=0)) println(list.filter(_ % 2 !=0)) //2.map //把集合中的每个数.

val list=List(1,3,5,7,2,89) val set=Set(23,34,423,75) // 1.获取集合长度 println(list.length) // 2.获取集合大小 println(set.size) //3.循环遍历 for (elem <-list) println(elem) set.foreach(println) //4.迭代器 for (elem<-list.

Map的分类一、可变Map第一步：创建可变Map第二步：删除元素第三步：修改元素第四步：合并两个Map第五步：可变Map代码+代码图如下二、不可变Map第一步：创建Map第二步：访问元素第三步：不可变Map代码+代码图如下一、可变Map可变Map：直接可以更改原位置的元素不用返回新的值不可变Map：不可直接对原位置的元素进行更改 会返回一个新的值(需定义 VAL 值名)第一步：创建可变Mapval map1:mutable.Map[String,Int]=mutable.Map("a"-&gt

集合分类一、不可变集合1.不可变集合步骤第一步：创建Set 不可变集合第二步：添加元素第三步：合并set第四步：删除元素2.不可变集合代码+代码结果二、可变集合1.可变集合步骤第一步：创建可变集合第二步：添加元素第三步：删除元素2.合并Set3.可变集合代码+代码图如下一、不可变集合可变集合：直接可以更改原位置的元素不用返回新的值不可变集合：不可直接对原位置的元素进行更改 会返回一个新的值(需定义 VAL 值名)1.不可变集合步骤第一步：创建Set 不可变集合val set1=Set(13,

列表分类一、不可变列表(Immutable_List)1.创建不可变列表第一步：创建不可变列表第二步：访问和遍历第三步：添加元素2. 自定义创建不可变列表3.把列表合并为子列表4.合并列表5.代码源码+代码结果一、可变列表1.创建可变列表(Mutable_List)第一步：创建不可变列表第二步：访问和遍历第三步：添加元素2.自定义创建I.把列表合并为子列表II.合并列表可变列表代码源码+代码结果图可变列表：直接可以更改原位置的元素不用返回新的值不可变列表：不可直接对原位置的元素进行更改 会返回一个新的

集合—数组一、数组1.不可变数组(ImmutableArray)第一步 ：创建不可变数组第二步：对数组中的元素位置赋值第三步：循环遍历的四种方法I. 普通循环遍历II.直接遍历所有元素,增强for循环III.迭代器VI.Foreach方法第四步：追加数组元素第五步：查看不可变数组源码I.代码源码II.代码结果如下2.可变数组(MutableArray)第一步：创建可变数组第二步：访问元素第三步：添加元素第四步：删除元素I.按元素位置删除II.按元素值删除3.数组转换I.可变数组转换为不可变数组->（小

object Test_Inherit { def main(args: Array[String]): Unit = { val student1=new Student7("lyt",18) student1.printInfo() val student2=new Student7("Alice",39,"std2529165097") student2.printInfo() val student3 =new Student8("雷云腾",19,"25

object Test17_Extends { def main(args: Array[String]): Unit = { val student17:Student17 = new Student17(" alice", 18) student17.study() student17.sayHi() val person:Person17 = new Student17(" bob", 13) //子类的对象赋值给父类的引用 person.sayHi()

package Chapter06object Test_Ball { def main(args: Array[String]): Unit = { //钻石问题特征叠加顺序 val myFootBall=new MyFootBall println(myFootBall.describe()) }}//特征叠加执行顺序//定义球trait Ball{ def describe():String ="ball"}//定义颜色特征//特质也可以继承t

package Chapter06//特质:多个类具有相同的特质(特征)时,就可以将这个特质独立出来,采用关键字trait声明object Test_Trait { def main(args: Array[String]): Unit = { val student:Student20=new Student20 student.sayHello() val student1:Student20=new Student20 student1.play() }}

object Test06_ConstructorParams { def main(args: Array[String]): Unit = { val student2 = new Student2 student2.name = "你好啊" student2.age = 18 println(s"sutdnet2:name=${student2.name} ${student2.age}") val student3 = new Student3("B

object Test05_Constructor { def main(args: Array[String]): Unit = { var student1=new Student1()//创建对象用类名 student1.Student1()//调用函数名 var student2=new Student1("雷云腾") var student3=new Student1("雷云腾",19) }}class Student1(){ //定义属性 v

def main(args: Array[String]): Unit = { //利用父类创建对象,调用父类属性 val person:Person=new Person() println(person.age) println(person.sex) person.printInfo() //利用子类创建对象,调用子类属性 val work:Work =new Work() println(work.sex) println(w..

def main(args: Array[String]): Unit = { //创建一个对象 val student = new Student() student.sex="雄性" student.age=18 println(student.sex) print(student.age) }}//定义一个类class Student{ //定义属性 封装==定义私有属性 private val name:String="Ali..

当函数返回值被声明为lazy时,函数的执行将被推迟, def main(args: Array[String]): Unit = { lazy val result: Int = sum(13, 47) 直到我们首次对此取值, 该函数才会执行. println("1.函数调用") // println("2.result=" + result) } def sum(a: Int, b: Int): Int = { println("3.sum调用").

//lambda表达式简写 def addByA1(a: Int): Int => Int = { (b: Int) => { a + b } } def addByA2(a:Int): Int => Int ={ b=>a+bdef addByA3(a: Int): Int => Int = a + _val addByAfour3 = addByA

object Test07_Practice_CollectionOperation { def main(args: Array[String]): Unit = { def arrayOperation(array: Array[Int], op: Int => Int): Array[Int] = { for (elem <- array) yield op(elem) } //定义一个加一操作 de

def main(args: Array[String]): Unit = { def f(n: Int): Int ={ println("f被调用") n + 1 //省略了return } //val result:Int=f(123:Int) //简化 def fun(): Int = { //无参 println("fun调用") 1 } val result = f(123)//对f(n)

object Test05_Lambda { def main(args: Array[String]): Unit = { val fun = (name: String) => { println(name) } fun("atguigu") //对name进行传参 println("============") //定义一个函数 def f(func: String => Unit): Unit = { fun

package Chapter05//从简的原则object Test04_Simplify { def main(args: Array[String]): Unit = { //return可以省略,Scala会使用函数体的最后一行代码作为返回值 def f1(name: String): String = { name } println(f1("雷云腾")) //如歌函数体只有一行代码,可以省略花括号 def f2(name:

package Chapter05object Test03_FunctionParameter { def main(args: Array[String]): Unit = { //1.可变参数 def f1(str: String*): Unit = { //*定义为可变参数 println(str) } f1("alice") f1("aaa", "bbb", "ccc") //装成一个数组形式放进去 //2.如果参数列表中存在

package Chapter05object Test02_FunctionDefine { def main(args: Array[String]): Unit = { // (1)函数1:无参,无返回值 def f1(): Unit = { println("1.无参,无返回值") } f1 println(f1()) //如果想有返回值把Unit换成数据类型 //(2)函数2:无参,有返回值 def f2():

object HangShu_Basic { def main(args: Array[String]): Unit = { //unit 函数返回值类型 //定义函数// def sayHi(name: String): Unit = {// println("hi" + name)// } //调用函数 sayHi("alice") //sayHi(name: String) // 调用对象方法 HangShu_Basic.sayH

函数式编程1. HangShu_Basic2. Test02_FunctionDefine3. Test03_FunctionParameter4. Test04_Simplify5. Test05_Lambda1. HangShu_Basic//定义函数 def sayHi(name: String): Unit = { println("hi" + name) } //调用函数 sayHi("alice") //sayHi(name: String)

循环定义的方法1.Scala—For循环<1> 嵌套For循环2.集合循环遍历3.循环守卫—删除<1>循环步长4. 代码结果1.Scala—For循环 //常用定义for循环的三种方法 for (i:Int<-1 to(10)){ print(i+ ".Hello World") } for (i<- Range(1,10)){ println(i+".hello world") } for (i &lt

运算符的作用运算符的常识运算符的常识def main(args: Array[String]): Unit = { //1.算数运算符 val result1: Int = 10 / 3 println(result1) val result2: Double = 10 / 3 println(result2) val result: Double =10.0/3 println(result.formatted("%.2f")) v

import java.io.{File,PrintWriter}import scala.io.Sourceobject Test06_FileI0 { def main(args: Array[String]): Unit = { //1.从文件中读取数据 Source.fromFile("E:/scalaStudy/Test").foreach(print)//前两个单词代表读取数据,后两个单词代表打印出来 正常相对目录用/表示 //2.将数据写入文件 val