1 方法和函数
1.1 方法的使用细节
1.2 函数的使用细节
1.3 函数作为参数传递
package com._51doit.day02.demo.function_method
/**
* FileName: Demo2
* Author: 多易教育-DOIT
* Date: 2020/10/31 0031
* Description:
*/
object Demo2 {
/**
* 方法和函数实现一样的功能
* 函数 可以单独存在 可以作为参数 或者是返回值 简洁 灵活
*/
/**
* 方法两个参数
*
* @param x int值
* @param f 函数 处理Int 返回Int
* @return
* opt方法对Int数据处理的逻辑的灵活的多变的 取决于传入的f
*/
def opt(x: Int, f: Int => Int): Int = {
// 使用函数 处理参数一 , 传入不同的函数 处理方式不同
f(x)
}
val f = (x:Int)=>{
x*x
}
def main(args: Array[String]): Unit = {
println(opt(12, f))
/* println(opt(12, x => x * x))
println(opt(12, x => x * x * x))*/
// 参数二 类
// Collections.sort(list , new Com)
}
}
1.4 函数和方法总结
package com._51doit.day02.demo.function_method
/**
* FileName: BinarySearch
* Author: 多易教育-DOIT
* Date: 2020/10/31 0031
* Description:
*/
object BinarySearch {
/**
* 参数一 数组
* 参数二 要找的元素
* 返回 元素的位置
* binary(arr , e){
* //定义起始点 和结束点
* var start =0
* var end = arr.len
* while(){
* var mid = (start+end) / 2
* if(arr(mid)==e) return mid
* else if(arr(mid)>e) end = mid -1
* }
* }
* @param arr
* @param e
*/
def binarySearch(arr: Array[Int], e: Int): Int = {
// 如果数组中没有元素 返回
if (arr.length <= 0) {
return -1
}
var start = 0
var end = arr.length - 1
var res = -1
while (start <= end) {
var mid = (start + end) / 2
if (arr(mid) == e) {
res = mid
return res
}else if(arr(mid)>=e){ // 要找的元素在中间值的左边
end = mid -1
}else{
start = mid+1
}
}
res
}
def main(args: Array[String]): Unit = {
println(binarySearch(Array(1, 3, 5, 7, 9, 10, 23, 56, 78), 100))
}
}
1.5 函数和方法转换
方法和函数都能实现一样的功能 , 那么函数可以作为参数传递 , 方法不能 ,
如果我们有某种功能的方法 , 没有这种功能的函数 如果想使用处理逻辑作为参数那么必须写一个一样功能的函数
其实方法可以转换成函数 方法名 _
opt("hello",m) 将方法传入参数 底层直接将方法转换成函数
/**
* FileName: Demo3
* Author: 多易教育-DOIT
* Date: 2020/10/31 0031
* Description:
* 函数可以作为方法的参数
*/
object Demo3 {
/**
* 函数
*/
val f = (str:String)=>{
str.toUpperCase
}
/**
* 方法
* @param str
* @return
*/
def m(str:String):String={
str.toUpperCase
}
val f2 = m _
/**
* 方法 参数二 函数
* @param str
* @param f
* @return
*/
def opt(str:String , f :String=>String): String ={
f(str)
}
def main(args: Array[String]): Unit = {
println(opt("hello", f))
// 方法不能单独存在
// 在底层将方法传入参数的时候会将方法转换成函数
println(opt("hello", m))
}
}
2 集合
scala中的集合分为两种 ,可变集合和不可变集合, 不可变集合可以安全的并发的访问!
集合的类主要在一下两个包中
- 可变集合包 scala.collection.mutable
2) 不可变集合包 scala.collection.immutable 默认的
scala默认使用的是不可变的集合 , 因此使用可变的集合需要导入可变集合的包
scala的集合主要分成三大类
- Seq 序列
- Set 不重复集
- Map 键值映射集
注意: 所有的集合都继承自Iterator迭代器这个特质
2.1 数组
package com._51doit.day02.demo.array
/**
* FileName: ArrayDemo1
* Author: 多易教育-DOIT
* Date: 2020/10/31 0031
* Description:
* 1 数组的定义
* 2 数组默认是不可变的(长度)
* 2.1 不可变的数组中的元素可变 arr1(index) = newvalue
*/
object ArrayDemo1 {
def main(args: Array[String]): Unit = {
// 数组的定义
val arr1: Array[Int] = Array(1, 2, 3, 4)
val arr2: Array[String] = Array[String]("hello", "hi", "zaima", "gun")
// 给数组的元素再赋值
arr1(1) = 100
arr1.foreach(println) // 1 100 3 4
// val newArr: Array[Int] = arr1.drop(2) // 从头删除n个
// newArr.foreach(println)
}
}
package com._51doit.day02.demo.array
import com._51doit.day02.demo.pojo.User
/**
* FileName: SortDemo
* Author: 多易教育-DOIT
* Date: 2020/10/31 0031
* Description:
*/
object SortDemo {
def main(args: Array[String]): Unit = {
val users = Array(
User(1,"yangmi",32),
User(2,"yangying",30),
User(3,"yangguo",722),
User(4,"yangyang",39),
User(5,"yshulin",18),
)
// users.sorted
// val res: Array[User] = users.sortBy(user => user.name)
/**
* User(3,yangguo,722)
* User(1,yangmi,32)
* User(4,yangyang,39)
* User(2,yangying,30)
* User(5,yshulin,18)
*/
val res: Array[User] = users.sortWith((u1, u2) => u1.name > u2.name)
res.foreach(println)
}
}
package com._51doit.day02.demo.array
/**
* FileName: ArrayDemo3
* Author: 多易教育-DOIT
* Date: 2020/10/31 0031
* Description:
*/
object ArrayDemo3 {
def main(args: Array[String]): Unit = {
val arr = Array("a" , "c" ,"n")
//val arr2: Array[String] = arr.:+("xxxx")
val arr2: Array[String] = arr:+("xxxx") // list集合
val ints1 = Array(1,3,5,7)
val ints2 = Array(2,4,6,8)
// val ints3: Any = ints1.:++ ints2 //
val tuples: Array[(String, Int)] = arr.zip(ints1)
tuples.foreach(e=>print(e+" "))
}
}
可变数组 : 数据的长度可变
可变数组需要导包 导包的方式是 /*import scala.collection.mutable.ArrayBuffer*/ import scala.collection.mutable._
package com._51doit.day02.demo.array
/*import scala.collection.mutable.ArrayBuffer*/
import scala.collection.mutable._
/**
* FileName: ArrayBuffer
* Author: 多易教育-DOIT
* Date: 2020/10/31 0031
* Description: 可变的数组
* 1 定义
* 1.1 val b = new ArrayBuffer[String]()
* 1.2 ArrayBuffer[Int](1,2,3,4)
* 2 append 追加元素
* 3 +=(ele) 添加一个元素
* 4 -=(ele) 删除最后一个元素
* 5 ++= --= 合并移除一个数组
* 6 remove(1 ,2) 参数一 index 参数二 从此开始删除个数
* remove(1) 参数是index
*/
object ArrayBufferDemo1 {
def main(args: Array[String]): Unit = {
// 1 定义可变数组
val b = new ArrayBuffer[String]()
// 添加元素
b.append("tom1")
b.append("tom2")
println(b.length)
b.foreach(println)
// 定义可变数据组 可以初始值
val arr1: ArrayBuffer[Int] = ArrayBuffer[Int](1, 3, 5, 7, 9)
val arr2: ArrayBuffer[Int] = ArrayBuffer[Int](2,4,6,8)
arr1++=arr2
arr1.foreach(e=>print(e+" "))
println()
arr1.remove(1)
arr1.foreach(e=>print(e+" "))
/* arr.append(2)
arr+=(100)
arr-=(5)
arr.foreach(e=>print(e+" "))*/
}
}
2.2 list
不可变list
package com._51doit.day02.demo.list
/**
* FileName: ListDemo1
* Author: 多易教育-DOIT
* Date: 2020/10/31 0031
* Description: List集合 在Seq
* 可变的
* 不可变的
* 1 定义 1) List(1, 2, 3, 4, "jim", "tom")
* 2) list = "JAVA" :: "JS" :: Nil
* 2 :+
* 3 ++
* 4 take(n) 从前面获取n个元素 返回新的list
* 5 takeRight
* 6 ls1.length ls1.size 长度
* 7 isEmpty
* 8 list集合的取值 ***** ls1(index)
* 9 distinct
*/
object ListDemo1 {
def main(args: Array[String]): Unit = {
// 不可变list
// 定义 1
val ls1 = List(123 , 34,34)
val string: String = ls1.mkString("--")
println(string)
val ls2 = List[Any](1, 2, 3, 4, "jim", "tom")
val ls: List[Any] = ls1.distinct
println(ls)
val ls3 = List[Int](1, 2, 3, 4)
// 定义方式 2
val list = "JAVA" :: "JS" :: Nil
val newls: List[Any] = ls1 :+ ("jack")
val newls2: List[Any] = ls2 ++ ls3 // ++
val newls3: List[Any] = ls2.take(2)
val newls4: List[Any] = ls2.takeRight(2)
val b: Boolean = ls1.isEmpty
println(ls1(0))
if(b)println("空集合")
//if(ls1.length==0)println("空集合")
newls4.foreach(e=>print(e+" "))
// val str: String = ls1 + ("cat") // List(1, 2, 3, 4, jim, tom)c
}
}
可变List
package com._51doit.day02.demo.list
import scala.collection.mutable.ListBuffer
/**
* FileName: ListBufferDemo
* Author: 多易教育-DOIT
* Date: 2020/10/31 0031
* Description:
* 1 可变list集合的定义ListBuffer(1, 2, 3, 4)
* 2 append(elements:Int*) 可变参数的方法
*/
object ListBufferDemo {
def main(args: Array[String]): Unit = {
val ls = List(1, 2, 3)
val lb1: ListBuffer[Int] = ListBuffer(1, 2, 3, 4)
val lb2: ListBuffer[Int] = ListBuffer(3, 4,5,6)
//ls += 12
/*lb1 += 23
println(lb1)
lb1-= 3
println(lb1)
lb1++=lb2
println(lb1)
lb1--=lb2*/
lb1--=lb2 // 除去交集
lb1.append(11,22,33)
// lb1.remove()
lb1.append()
println(lb1)
}
}
可变参数的方法
(str:String*)
package com._51doit.day02.demo.list
/**
* FileName: ArgsDemo
* Author: 多易教育-DOIT
* Date: 2020/10/31 0031
* Description:
* (String...str)
* str:String*
* 可变参数的方法只能有一个可变列表且在列表的最后
*/
object ArgsDemo {
def m(x:Int , str:String*): String ={
var res:String = ""
for (elem <- str) {
res+=elem
}
res
}
def main(args: Array[String]): Unit = {
println(m("hello", "world", "jim"))
}
}
2.3 元组
组 (String,Int,String) 替代 Bean来简化数据的封装 操作某个位置的数据和操作bean的属性一样方便元祖的定义
元组的取值
元组的遍历
元组的嵌套 取值
对偶元组
对偶元组反转
package com._51doit.day02.demo.tuple
/**
* FileName: TupleDemo1
* Author: 多易教育-DOIT
* Date: 2020/10/31 0031
* Description:
* 元组 (String,Int,String) 替代 Bean来简化数据的封装
* 操作某个位置的数据和操作bean的属性一样方便
* 只能存储22个元素
* 1 元组的定义
*/
object TupleDemo1 {
def main(args: Array[String]): Unit = {
// 1 元组的定义
val tp = new Tuple4(1, 2, 3, 4)
val tuple: (String, Int, Int, String, Boolean) = ("tom", 1, 3, "jim", true)
// println(tp._3)
// println(tuple._4)
// 遍历每个元素
val iterator: Iterator[Any] = tuple.productIterator
iterator.foreach(println)
//2 元组嵌套
val tuple1: ((Int, Int, Int, Int), (Int, Int, Int, Int, Int, Int, Int)) = ((1, 2, 3, 4), (2, 3, 4, 5, 6, 7, 8))
//3 对偶元组 (k,v)(k,v)(k,v)(k,v)
val tuple2 = (("zss", 23), ("lss", 33))
tuple2._2._1 //lss
//4 拉链操作
val mps = Array("em" , "sl" , "wd" ,"kl","xiaoyao" , "gb")
val ps = Array("zhiruo" ,"wukong","zsf","taoge","xingge")
val arr: Array[(String, String)] = mps.zip(ps)
arr.foreach(println)
val tuple3: (String, (String, String, String, String)) = ("sl", ("ts", "zbj", "ss", "wk"))
}
}
2.4 set
2.5 map
Map的定义
package com._51doit.day02.demo.map
/**
* FileName: MapDemo1
* Author: 多易教育-DOIT
* Date: 2020/10/31 0031
* Description:
* 1 Map的定义
* 1)
* 2)
* 2 get(key)
* 3 getOrElse 参数一 key 参数二 没有key value的默认值
* 4 mp.keys 获取所有的key
* 5 根据key获取所有的value
* 6 mp2.values
* 7 mp.toList
*/
object MapDemo1 {
def main(args: Array[String]): Unit = {
// Map 定义1
val mp = Map[String ,Int](("zss", 23), ("lss", 33), ("ww", 21))
//定义2
val mp2 = Map[String , String]("sl" -> "fsy", "em" -> "zhir", "wd" -> "zsf")
// map转换成集合 对偶元组的list集合
val ls: List[(String, Int)] = mp.toList
ls.foreach(tp=>{
println(tp._1)
})
/* val values: Iterable[String] = mp2.values
values.foreach(println)*/
/* val keys: Iterable[String] = mp.keys
keys.foreach(k=>{
val op: Option[Int] = mp.get(k)
println(op.get)
})*/
// println(str)
// 根据key取取值 1) Some(v) 2) None
/* val op: Option[Int] = mp.get("zs2s")
if(op.isDefined){// Some
val res: Int = op.get
println(res)
}*/
// 判断
/* if(op!=None){
val res: Int = op.get
println(res)
}*/
}
}
Map的遍历
val keys1: Iterable[String] = mp.keys
val values1: Iterable[Int] = mp.values
//根据key获取所有的value
val keys: Iterable[String] = mp.keys
keys.foreach(k=>{
val v: Int = mp.get(k).get
println(s"key:${k} , value:$v")
}) val ls: List[(String, Int)] = mp.toList
ls.foreach(tp=>{
println(s"key:${tp._1} - value: ${tp._2}" )
})for (elem <- mp) {
print(elem._1+" ")
print(elem._2)
println()
} for ((k,v) <- mp) {
println(s"$k - $v")
}
for ((_,v) <- mp) {
println(s"$v")
}
for ((k,_) <- mp) {
println(s"$k")
}
// 第五种
mp.map(tp=>{
val k: String = tp._1
val v: Int = tp._2
})
// 第六种
mp.foreach(tp=>{
val k: String = tp._1
val v: Int = tp._2
})package com._51doit.day02.demo.map
/**
* FileName: MapDemo3
* Author: 多易教育-DOIT
* Date: 2020/10/31 0031
* Description:
* 不可变的Map和可变的Map名字一样 只能使用包名区分
* 默认是不可变集合
* mutable.Map[Int,Int]() put
*/
object MapDemo3 {
def main(args: Array[String]): Unit = {
import scala.collection._
// 可变的map put
val map = mutable.Map[Int,Int]()
map.put(1,3)
// 不可变的Map
val mp = immutable.Map[String, Int](("zss",11))
val map1 = new mutable.HashMap[String, Int]()
map1.put("a",22)
map1.put("a",23)
map1.put("b",23)
map1.remove("")
map1.keySet
map1.foreach(println)
}
}