2020-11-03-Scala-复习-5(集合操作)

一个问题:

1.共同好友案例(理解类型的转换 迭代器和可迭代对象)

import java.io.File
import scala.io.Source

//理解其中的结构
object Test3 {
  def main(args: Array[String]): Unit = {
    //读取全部的内容 ,全部
    val list1 = Source.fromFile(new File("src/main/resources/friend.txt")).getLines()
    val list3 = list1.toList
     println(list3)
    val iterable = list1.to(Iterable)
    val list2 = iterable.toList



    val list = Source.fromFile(new File("src/main/resources/friend.txt")).getLines().to(Iterable).toList

    var result = list.map(data => {
      var txt = data.split(":")
      val user = txt(0)
      val frends = txt(1).split(",")
      (user, frends.toList)
    }
    )
    var result1 = for (i <- 0 until result.length; j <- i +1 until result.length) yield {
      ((result(i)._1 + "与" + result(j)._1 + "的共同好友有"), (result(i)._2.intersect(result(j)._2)))
    }
    result1.filter(data => data._2.length > 0).foreach(println)

  }
}

2.aggregate

object Test6 {
  def main(args: Array[String]): Unit = {
    val arr = List(List(1, 2, 3), List(3, 4, 5), List(2), List(0))
    val list  = List(1,2,3,4,5,6)

    //这里的reduce替代为sum
     arr.foldLeft(0)((data1, data2) =>
      data1 + data2.reduce(_+_)
    )
     arr.aggregate(0)((x,y)=>{x+ y.reduce(_+_)},_+_)
    //理解这个函数 ,前一部分是局部运算,后一部分是对局部的迭代
    println(list.aggregate(0)({_ + _}, _+_))
    println(list.aggregate(0)(_ + _, null))
  }
}

3.一个案例(groupBy和aggregate的模式匹配)

//1、使用Scala实现一个方法，使得返回数组中，分别等于num，大于num，小于num的元素的个数。
：getNum（Array（1,2,3,4,5,6），2）结果为（1,1,4）

//1、使用Scala实现一个方法，使得返回数组中，分别等于num，大于num，小于num的元素的个数。
// 例：getNum（Array（1,2,3,4,5,6），2）结果为（2,2,3）
object Test7 {
  def main(args: Array[String]): Unit = {
    val arr = Array(1, 2, 3, 4, 5, 6)
    //方法一
    println((arr.filter(_ > 2).size,
      arr.filter(_ == 2).size,
      arr.filter(_ < 2).size))


    //方法二使用groupby分组
    arr.groupBy(data => data match {
      case x if x > 2 => "x>2" + 2
      case y if y == 2 => "x==2" + 2
      case z if z < 2 => "z<2" + 2
    })
      .map(_._2.size).foreach(println)

    //对下面函数的理解,x是初始值不断改变,y是arr的每个值
    //  arr.aggregate(0)((x,y)=>{x+ y.reduce(_+_)},_+_)
    var a =0
    var b =0
    var c =0
     //编译报错,运行正确
   var result = arr.aggregate(a, b, c)({ (x, y) =>
        ((if (y < 2) {x._1 + 1} else x._1),
        (if (y == 2) {x._2 + 1} else x._2),
        (if (y > 2) {x._3 + 1} else x._3))
    },(x,y) => (x._1 + y._1 ,x._2 + y._2  , x._3  + y._3))
    //可以把后面的 (x,y) => (x._1 + y._1 ,x._2 + y._2  , x._3  + y._3)  换为null 因为已经分组完成
    println(result)
  }

4.理解aggregate 和 foldLeft 第一个参数的意义

    val  list = List[Int]()

    arr.aggregate(list)((fun),null).foreach(println)
    println(list)
  }
  //换成listbuffer  使用append
  def fun (list: List[Int], int: Int)={
        list :+ int
        list
  }
  def fun1 (list: ListBuffer[Int], int: Int)={
    list.append(int) 
    list
  }
}