初识Scala (三)

1.函数

Map函数

 1Map中的元素主要是映射用的，一个值进去，一个值出来
 2scala> val c=Array(1,2,3,4,5)
 3c: Array[Int] = Array(1, 2, 3, 4, 5)
 4
 5scala> c.map((x:Int)=> x*2)
 6res17: Array[Int] = Array(2, 4, 6, 8, 10)
 7
 8scala> c.map(_*2)
 9res18: Array[Int] = Array(2, 4, 6, 8, 10)
10
11scala>       val array = Array(Array(("ruoze",30)),Array(("jepson",20)))
12array: Array[Array[(String, Int)]] = Array(Array((ruoze,30)), Array((jepson,20)))
13
14scala>       array.map(x=>x.map(t => (t._1,t._2+2)))
15res19: Array[Array[(String, Int)]] = Array(Array((ruoze,32)), Array((jepson,22)))
16
17取值赋值
18scala> val a=Map("A" -> 2,"B" -> 3)
19a: scala.collection.immutable.Map[String,Int] = Map(A -> 2, B -> 3)
20
21scala> a("A")
22res3: Int = 2
23
24scala> a
25res5: scala.collection.immutable.Map[String,Int] = Map(A -> 2, B -> 3)
26
27scala> a.get("A")
28res6: Option[Int] = Some(2)
29
30scala> a.get("C")
31res7: Option[Int] = None
32
33scala> a.get("A").get
34res8: Int = 2
35scala> a.get("C")
36res9: Option[Int] = None
37
38scala> a.get("C").getOrElse("NONE")
39res10: Any = NONE

filter函数

1按条件过滤元素
2scala> c
3res21: Array[Int] = Array(1, 2, 3, 4, 5)
4
5scala> c.filter(_ >2)
6res22: Array[Int] = Array(3, 4, 5)

take函数

1取出前几个元素
2scala> c.take(3)
3res23: Array[Int] = Array(1, 2, 3)

reduce函数

 1将集合中的元素通过一定的运算或操作将其规约为一个值
 2scala> c.reduce((a,b)=>a+b)
 3res24: Int = 15
 4
 5scala>  c.reduce(_+_)
 6res25: Int = 15
 7
 8scala> c.reduceRight((a,b)=>{
 9     |         println(a+"  "+b)
10     |         a-b
11     |       })
124  5
133  -1
142  4
151  -2
16res26: Int = 3
17
18scala> c.reduceLeft((a,b)=>{
19     |         println(a+"  "+b)
20     |         a-b
21     |       })
221  2
23-1  3
24-4  4
25-8  5
26res27: Int = -13

zip函数

1将两个列表的数据合并起来
2scala> val a=List(1,2,3,4)
3a: List[Int] = List(1, 2, 3, 4)
4
5scala> val b=List("a","b","c","d")
6b: List[String] = List(a, b, c, d)
7
8scala> a.zip(b)
9res28: List[(Int, String)] = List((1,a), (2,b), (3,c), (4,d))

flatten函数

1将元素拿出来
2scala> val f = Array(Array(1,2),Array(3,4),Array(3,4))
3f: Array[Array[Int]] = Array(Array(1, 2), Array(3, 4), Array(3, 4))
4
5scala>       f.flatten
6res29: Array[Int] = Array(1, 2, 3, 4, 3, 4)

flatmap函数

 1相当于flatten跟map结合
 2scala> val f = Array(Array(1,2),Array(3,4),Array(3,4))
 3f: Array[Array[Int]] = Array(Array(1, 2), Array(3, 4), Array(3, 4))
 4
 5scala>       f.flatten
 6res29: Array[Int] = Array(1, 2, 3, 4, 3, 4)
 7
 8scala> f.flatMap(_.map(_*2))
 9res30: Array[Int] = Array(2, 4, 6, 8, 6, 8)
10scala> f.map(_.map(_*2))
11res32: Array[Array[Int]] = Array(Array(2, 4), Array(6, 8), Array(6, 8))

find函数

 1查找最多满足条件的第一个元素
 2scala> val li = Array(1,3,2,4,5)
 3li: Array[Int] = Array(1, 3, 2, 4, 5)
 4
 5scala>       li.find(_>3)
 6res36: Option[Int] = Some(4)
 7
 8scala> val li = Array(1,3,2,6,5)
 9li: Array[Int] = Array(1, 3, 2, 6, 5)
10
11scala>       li.find(_>3)
12res37: Option[Int] = Some(6)

groupby函数

1自定义分组
2scala> val e=Array(("a",100),("b",10),("a",19),("d",10))
3e: Array[(String, Int)] = Array((a,100), (b,10), (a,19), (d,10))
4
5scala>       e.groupBy(x=>x._1)
6res38: scala.collection.immutable.Map[String,Array[(String, Int)]] = Map(b -> Array((b,10)), d -> Array((d,10)), a -> Array((a,100), (a,19)))

sorted函数

 1升序排列
 2scala> val a=Array("c","b","a")
 3a: Array[String] = Array(c, b, a)
 4
 5scala> a.sorted
 6res39: Array[String] = Array(a, b, c)
 7
 8scala> val b=Array(1,45,64,26)
 9b: Array[Int] = Array(1, 45, 64, 26)
10
11scala>       b.sorted
12res40: Array[Int] = Array(1, 26, 45, 64)

sortby函数

1自定义规则排序
2scala> val b=Array(1,45,64,26)
3b: Array[Int] = Array(1, 45, 64, 26)
4
5scala> b.sortBy(x => -x)
6res41: Array[Int] = Array(64, 45, 26, 1)

2.逆变协变

对于一个带类型参数的类型，比如 List[T]，如果对A及其子类型B，满足 List[B]也符合 List[A]的子类型，那么就称为covariance(协变)，如果 List[A]是 List[B]的子类型，即与原来的父子关系正相反，则称为contravariance(逆变)

1当我们定义一个协变类型List[A+]时，List[Child]可以是List[Parent]的子类型。
2当我们定义一个逆变类型List[-A]时，List[Child]可以是List[Parent]的父类型

Consumer定义成协变类型的，Consumer[Bird]是Consumer[Animal]的子类型，所以它可以被赋值给c2

1class Animal {}
2class Bird extends Animal {}
3class Consumer[+T](t: T) {
4}
5class Test extends App {
6    val c:Consumer[Bird] = new Consumer[Bird](new Bird)
7    val c2:Consumer[Animal] = c
8}

Consumer[-T]定义成逆变类型，所以Consumer[Bird]被看作Consumer[Hummingbird]的子类型，故c可以被赋值给c2

1class Animal {}
2class Bird extends Animal {}
3class Consumer[-T](t: T) {
4}
5class Test extends App {
6    val c:Consumer[Bird] = new Consumer[Bird](new Bird)
7    val c2:Consumer[Hummingbird] = c
8}

3.上界下界

泛型用于指定方法或类可以接受任意类型参数，参数在实际使用时才被确定，泛型可以有效地增强程序的适用性，使用泛型可以使得类或方法具有更强的通用性。

在指定泛型类型时，有时需要界定泛型类型的范围，而不是接收任意类型。比如，要求某个泛型类型，必须是某个类的子类，这样在程序中就可以放心的调用父类的方法，程序才能正常的使用与运行。此时，就可以使用上下边界Bounds的特性；

Scala的上下边界特性允许泛型类型是某个类的子类，或者是某个类的父类；

(1) S <: T

这是类型上界的定义，也就是S必须是类型T的子类（或本身，自己也可以认为是自己的子类)。

(2) U >: T

这是类型下界的定义，也就是U必须是类型T的父类(或本身，自己也可以认为是自己的父类)。

 1定义上界
 2//Comparator(java)  <==> Ordering(scala)
 3// Comparable   <==>  Ordered
 4
 5class Maxvalue[T <: Comparable[T]](x:T,y:T){
 6  def compare =if (x.compareTo(y)>0) x else y
 7}
 8
 9    val value = new Maxvalue[Integer](10,20)
10    println(value.compare)

 1定义下界
 2
 3class GenericTest2{
 4
 5  def choose[T <: Comparable[T]](one:T,two:T): T ={
 6    if(one.compareTo(two) > 0) one else two
 7  }
 8}
 9
10class Boy(val name:String,var age:Int) extends Comparable[Boy]{
11  override def compareTo(o: Boy): Int = {
12    this.age - o.age
13  }
14}
15
16object GenericTestTwo{
17  def main(args: Array[String]): Unit = {
18    val gt = new GenericTest2
19    val huangbo = new Boy("huangbo",60)
20    val xuzheng = new Boy("xuzheng",66)
21    val boy = gt.choose(huangbo,xuzheng)
22    println(boy)
23  }
24}

视图界定
视图界定：底层隐式转换了

1class Maxvalue2[T <% Comparable[T]](x:T,y:T){
2  def compare =if (x.compareTo(y)>0) x else y
3}
4
5    val value1 = new Maxvalue2(10,20)
6    println(value1.compare)

识别 下方二 维码 ，即可关注公众号获取最新大厂技术