2021-05-16

@Scala day06

分类的三种方法

sorted

冒泡：
比较两个值的大小
Arrays.sort()
Collections.sort()
Comarable x.compareTo(y) 让元素的类实现接口 自己·和自己的兄弟对象比较
Comparator(x,y) 比较器 比较这个对象

scala:
   不管是可变集合还是不可变集合，都是返回一个新的排好序的集合
   原集合不动
sorted
   默认都是自然排序（升序）
   1.让排序的类型有排序的功能
    Ordered 就是Java中的Comparable
   2.找一个第三方的比较器
    Ordering 就是Java中的Comparator

package com.syf.scala1015day06
/**
  * Author Amily
  * Date 2021/5/16
  */
class user(val age:Int,val name: String)extends Comparable[user]{
  override def compareTo(o: user): Int = age-o.age

  override def toString: String = s"[age=$age,name=$name]"
}
object Sort1 {
  def main(args: Array[String]): Unit = {
    /*val list1:List[Int]=List(30,50,70,60,10,20)
    println(list1.sorted)
    println(list1.sorted.reverse)
    */

    val list1:List[user] =List(new user(10,"a"),new user(20,"b"),new user(15,"C"))
//    val list1:List[Int]=List(30,50,70,60,10,20)
    //Ordering.Int.reverse 反转Int类型的比较器
//    val list2:List[Int]=list1.sorted(Ordering.Int.reverse)
    implicit val o=list1.sorted(new Ordering[user]{
      override def compare(x: user, y: user): Int = x.age-y.age
    })
//    val list2:List[user]=list1.sorted(new Ordering[user]{
//      override def compare(x: user, y: user): Int = x.age-y.age
//    })
    val list2:List[user]=list1.sorted
    println(list2)
  }
}

sortBy

sortBy
不需要提供任何的逻辑代码，只需指定要排序的指标

package com.syf.scala1015day06
/**
  * Author Amily
  * Date 2021/5/16
  */
class Person(val age:Int,val name:String){
  override def toString: String =s"[age=$age,name=$name]"
}
object Sort2 {
  def main(args: Array[String]): Unit = {
//    val list1:List[Int]=List(30,50,70,60,10,20)
//    val list2:List[Int]=list1.sortBy(x=>x)(Ordering.Int.reverse)
//    println(list2)
val list1:List[String]=List("zzzzz","hello","world","aiguigu","aaa","b")
//    val list2:List[String]=list1.sortBy(x=>x)
    //按照字符串的长度升序进行排序
//    val list2:List[String]=list1.sortBy(x=>x.length)
    //先按照长度升序排，长度相等的时候使用字母表的升序排
    //如果是多个指标，就把这多个指标放在元素中返回
//    val list2:List[String]=list1.sortBy(x=>(x.length,x))
    //先按照长度降序排，长度相等的时候使用字母表的升序排
//    val list2:List[String]=list1.sortBy(x=>(x.length,x))(Ordering.Tuple2(Ordering.Int.reverse,Ordering.String))
    //先按照长度升序排，长度相等的时候使用字母表的降序排
//    val list2:List[String]=list1.sortBy(x=>(x.length,x))(Ordering.Tuple2(Ordering.Int,Ordering.String.reverse))
    val list:List[Person]=List(new Person(10,"a"),new Person(25,"b"),new Person(8,"c"),new Person(30,"d"))
    //年龄升序，年龄等姓名升序
    val list2:List[Person]=list.sortBy(user=>(user.age,user.name))
    println(list2)
  }
}

sortWith

sortWith
传递一个函数，然后，在函数里写你的比较规则

package com.syf.scala1015day06
/**
  * Author Amily
  * Date 2021/5/16
  */
object Sort3 {
  def main(args: Array[String]): Unit = {
    val list1:List[Int]=List(30,50,70,60,10,20)
//    val list2:List[Int]=list1.sortWith((x,y)=>x>y)
    //返回true：第一个排序在前，返回false，第一个排序在后
    val list2:List[Int]=list1.sortWith(_>_)
    println(list2)

  }
}

stream数组结构

惰性数据结构

package com.syf.scala1015day06
/**
  * Author Amily
  * Date 2021/5/16
  */
object Stream1 {
  def main(args: Array[String]): Unit = {
    val list1: List[Int] = List(30, 50, 70, 60, 10, 20)
    val s1: Stream[Int] = list1.toStream
    //    println(s1)
    //    println(s1.head)
    //    println(s1.tail.head)
    //    s1.foreach(println)
    //    println(s1)
    //强制求值
    //    println(s1.force)
    //    println(gets)
    //  }
    //  def gets:Stream[Int]={
    //    1 #:: gets

    println(fibSeq(10))
  }

  //斐波那契数列
  def fibSeq(n: Int): List[Int] = {
    def loop(a: Int, b: Int): Stream[Int] = {
      a #:: loop(b, a + b)
    }

    loop(1, 1).take(n).force.toList
  }
}

并行集合

package com.syf.scala1015day06
/**
  * Author Amily
  * Date 2021/5/16
  */
object Par1 {
  def main(args: Array[String]): Unit = {
    val list1:List[Int]=List(30,50,70,60,10,20)
//    list1.foreach(x=>println(Thread.currentThread().getName))
      list1.par.foreach(x=>println(Thread.currentThread().getName))
  }
}

scala和Java的互换

java的集合都是可变的
scala的集合有可变也有不可变
这些隐式转换可以完成Scala集合和Java集合的互转
我们会调用Java的一些类库，需要的参数一般是Java集合，从Java到Scala

package com.syf.scala1015day06
/**
  * Author Amily
  * Date 2021/5/16
  */
import java.util.( ArrayList => JAL)
object JavaScala {
  def main(args: Array[String]): Unit = {
    //这些隐式转换可以完成Scala集合和Java集合的互转
    //我们会调用Java的一些类库，需要的参数一般是Java集合，从Java到Scala
    import scala.collection.JavaConversions._
    val list:util.ArrayList[Int]=new JAL[Int]()
    list.add(10)
    list.add(100)
    list.add(20)
    list.add(200)
//    list+=1000
    for(e<-list){

    }
  }
}