18集合操作

集合操作

Zip拉链

object ZipDemo {

  def main(args: Array[String]): Unit = {
    //拉链函数
    val l1 = List(1,2,3,4,5)
    val l2 = List(6,7,8,9,10)
    //一对一配对
    //以短的为标准，多余的抛弃
    val l3:List[(Int,Int)] = l1.zip(l2)

    //以多的为标准
    //l1的默认值为-1 l2的默认值为-2
    val l4:List[(Int,Int)] = l1.zipAll(l2,-1,-2)

    //自己与自己的索引zip
    val index:List[(Int,Int)] = l1.zipWithIndex

    //unzip
    //二维元组
    val unzip:(List[Int],List[Int]) = l3.unzip

  }
}

Slide滑窗

object SlideDemo {
  def main(args: Array[String]): Unit = {
    val l1 = List(1,2,3,4,5)
    //滑窗函数
    //每次取3个 ，步长为1
    val it:Iterator[List[Int]] = l1.sliding(3,1)
    for (elem <- it) {
      println(elem)
    }
  }
  //List(1, 2, 3)
  //List(2, 3, 4)
  //List(3, 4, 5)
}

map

object MapDemo {
  def main(args: Array[String]): Unit = {
    val l1 = List(1, 2, 3, 4)
    //一进一出
    val res = l1.map(x => x * 2)
    val res1 = l1.map(_ * 2)
  }
}

foreach

object ForeachDemo {
  def main(args: Array[String]): Unit = {
    val l1 = List(1, 2, 3, 4)
    l1.foreach(println(_))
    l1.foreach(println)

   //部分应用函数
    val square = math.pow(_,2)
    val d = square(2)

    //相当于还是函数
    val prt = println(_)
    prt(1)
    l1.foreach(prt)
  }
}

filter

object FilterDemo {
  def main(args: Array[String]): Unit = {
    val l1 = List(1, 2, 3, 4)
    //过滤出符合条件的
    val l2: List[Int] = l1.filter(x => x > 1)
    val l3: List[Int] = l1.filter(_>1)
  }
}

flatten

object FlattenDemo {
  def main(args: Array[String]): Unit = {
    val l1 = List(List(1,2), List(1,3), List(1,2), List(1,2))
    //拍平 
    //降维 List(1, 2, 1, 3, 1, 2, 1, 2)
    val flatten = l1.flatten
    println(flatten)
  }
}

flatMap

object FlatMapDemo {
  def main(args: Array[String]): Unit = {
    val l1: List[String]  = List("hello world","hello hello","haha kkk")
    val l2: List[String] = l1.map(x=>x.split(" ")).flatten
    //确保flatMap返回是一个集合
    //等价于 map+flatten
    val l3: List[String] = l1.flatMap(x=>x.split(" "))
  }
}

reduce

object ReduceDemo {
  def main(args: Array[String]): Unit = {
    val l1 = List(1, 2, 3, 4)
    println(l1.reduce(_ + _))
  }
}

fold

object FlodDemo {
  def main(args: Array[String]): Unit = {
    val l1 = List(1, 2, 3, 4)
    //fold折叠
    //解决的reduce 最后结果类型单一化
    //fold =====>foldLeft
    val res = l1.foldLeft("==")((x,y)=>x+y)
    println(res)


    val res1 = l1.foldRight("==")((x,y)=>x+y)
    println(res1)

    //==1234
    //1234==
  }
}

object FoldDemo2 {
  def main(args: Array[String]): Unit = {
    val map1 = Map("1" -> 1, "2" -> 2)
    val map2 = Map("1" -> 10, "3" -> 9)

      //合并两个map value相加
    val map3 = map1.foldLeft(map2)((m, x) => {
      m + (x._1 -> (m.getOrElse(x._1, 0) + x._2))
    })
    println(map3.mkString(","))
//    1 -> 11,3 -> 9,2 -> 2
  }
}

groupBy

object GroupDemo {
  def main(args: Array[String]): Unit = {
    val l1 = List(1, 2, 3, 4)
    val map = l1.groupBy(_%2)
    
    println(map)
    //Map(1 -> List(1, 3), 0 -> List(2, 4))
  }
}

Sort

class User(val name: String, val age: Int) extends Comparable[User] {
  override def compareTo(o: User): Int = name.compareTo(o.name)
}

class User2(val name: String, val age: Int) extends Ordered[User2] {
  override def compare(that: User2): Int = name.compareTo(that.name)
}

object Sort1 {
  def main(args: Array[String]): Unit = {
    val l1 = List(1, 2, 3, 4, 9, 7, 5, 8)

    //sorted排序
    //默认升序
    //生成新对象
    l1.sorted

    //反转
    l1.sorted.reverse

    //复杂对象排序
    val l2 = List(new User("2", 2), new User("1", 1), new User("3", 3))

    l2.sorted
    l2.sorted.reverse
    val u1 = new User("2", 2)
    val u2 = new User("1", 1)
    u1.compareTo(u2)


    val l3 = List(new User2("2", 2), new User2("1", 1), new User2("3", 3))
    l3.sorted
    l3.sorted.reverse
    val u3 = new User2("2", 2)
    val u4 = new User2("1", 1)
    u3.compareTo(u4)
    //没有==
    val bool1 = u3 > u4
    val bool2 = u3 < u4
    val bool3 = u3 >= u4
    val bool4 = u3 <= u4

    l1.sorted(Ordering.Int)
    //反转 ，比的时候反转
    l1.sorted(Ordering.Int.reverse)

    //复杂对象

    l2.sorted(new Ordering[User] {
      override def compare(x: User, y: User): Int = x.age - y.age
    })
    //或者使用使用隐式值也可以
    implicit val order = new Ordering[User2] {
      override def compare(x: User2, y: User2): Int = x.age - y.age
    }

    //=====================================
    //sortedBy
    //得到新的集合
    val l5 = l1.sortBy(x => x)
    //函数返回什么就按什么排序
    val l6 = l1.sortBy(x => x.toDouble)
    //指定Ordering 函数柯里化
    l2.sortBy(_.age)(Ordering.Int.reverse)

    //先按照name升序，再按照age降序
    //弄成元组 最多到Tuple9
    l2.sortBy(x => (x.name, x.age))(Ordering.Tuple2(Ordering.String, Ordering.Int.reverse))

    //====================================
    //sortWith
    //定制性更强
    //升序
    l2.sortWith((x, y) => x.age < y.age)
    l2.sortWith(_.age < _.age)

  }
}