集合常用方法

集合常用方法

package chapter03

object test05 {

  def main(args:Array[String]):Unit={

    val list=List(1,2,3,4,1,3)

    //TODO 和
    println("sum= "+list.sum)

    //TODO 最大值
    println("max= "+list.max)

    //TODO 乘积 product
    println("produce= "+list.product)//24
    
    //TODO 反转 reverse
    println("reverse= "+list.reverse)

    //TODO 迭代 iterator
    for (elem <- list.iterator) {
      println(elem)
    }

    //TODO 映射 map(int=>B)
    val tupleList: List[(Int, Int)] = list.map(x=>{(x,1)})
    println(tupleList.mkString(","))

    val intToTuples: Map[Int, List[(Int, Int)]] = tupleList.groupBy(x=>{x._1})
    println("intToTuples "+intToTuples)
    intToTuples.foreach(t=>{println(t._1,t._2)})

    val intToInt2: Map[Int, Int] = intToTuples.map(x=>{(x._1,x._2.size)})
    println("intToInt2 "+intToInt2)
    println(intToInt2)

    //TODO 过滤 filter
    val ints: List[Int] = list.filter(x=>x%2==0)
    println("ints "+ints)

    //TODO 拉链,zip,关联后形成元组
    val list1 = List(1,3,5,7,9)
    val list2 = List(2,4,6,8)
    val tuples: List[(Int, Int)] = list1.zip(list2)
    println(tuples.mkString(",")) //(1,2),(3,4),(5,6),(7,8)

    //TODO 并集 union
    val unionList: List[Int] = list1.union(list2)
    println(unionList.mkString(",")) //(1,2),(3,4),(5,6),(7,8)

    //TODO 交集 intersect
    val intersectList: List[Int] = list1.intersect(list2)
    println(intersectList.mkString(",")) //

    //TODO 差集 diff
    val diffList: List[Int] = list1.diff(list2)
    println(diffList.mkString(",")) //

  }

}

package chapter03

object test06 {

  def main(args:Array[String]):Unit= {

    val list = List(1, 2, 3, 4, 1, 3)
    val stringList = List("11","12","22","23")

    //TODO 排序1 sortBy(int=>B)
    val ints: List[Int] = list.sortBy(x=>x)
    println(ints.mkString(","))

    //TODO 降序1 sortWith( (int,int)=>Boolean )
    val ints2: List[Int] = ints.sortWith((left,right) =>left>right)
    println(ints2.mkString(","))

    //TODO 排序2
    val sortStringList: List[String] = stringList.sortBy(x=>x.substring(1))
    println(sortStringList.mkString(","))

    //TODO 降序2
    val sortStringList2: List[String] = sortStringList.sortWith((left,right)=>left.substring(1).toInt>right.substring(1).toInt)
    println(sortStringList2.mkString(","))



  }

}

package chapter03

object test07 {

  def main(args:Array[String]):Unit={

    val list=List(1,2,3,4,1,3)

    //TODO groupBy（int=>k）
    val intToInts: Map[Int, List[Int]] = list.groupBy(x=>x)
    println("intToInts "+intToInts)//(intToInts,Map(2 -> List(2), 4 -> List(4), 1 -> List(1, 1), 3 -> List(3, 3)))
    intToInts.foreach(t=>{println((t._1,t._2))})

    val intToInts2: Map[Int, List[Int]] = list.groupBy(x=>(x%2))
    println("intToInts2 "+intToInts2)
    intToInts2.foreach(t=>{println(t._1,t._2)})

    val stringList = List("11","12","22","23")
    val stringToStrings: Map[String, List[String]] = stringList.groupBy(x=>x.substring(0,1))
    println("stringToStrings "+stringToStrings)  //(stringToStrings,Map(2 -> List(22, 23), 1 -> List(11, 12)))
    stringToStrings.foreach(t=>{println(t._1,t._2)})


  }

}

package chapter03

object test08 {

  def main(args:Array[String]):Unit={


    //TODO wordCount


    val wordList = List("hello", "scala", "hello", "scala", "hello", "python")
    //将相同的单词放在一起：groupBy
    val stringToStrings: Map[String, List[String]] = wordList.groupBy(x=>x)
    println("stringToStrings "+stringToStrings)

    //将数据结构进行转换：map
    val stringToInt: Map[String, Int] = stringToStrings.map(x=>(x._1,x._2.size))
    println("stringToInt "+stringToInt)

    //将map转化为list：toList
    val list: List[(String, Int)] = stringToInt.toList
    println("list "+list)

    //将数据进行排序：sortWith
    val tuples: List[(String, Int)] = list.sortWith((left,right)=>{left._2>right._2})
    println("tuples "+tuples)

    //取前两个：take
    val tuples2: List[(String, Int)] = tuples.take(2)
    println("tuples2 "+tuples2)




    //TODO 扁平化操作：将整体内容拆分成个体
     val fileList = List("hello scala", "hello python", "hello scala")
    println("fileList "+fileList)

    val flatMapList: List[String] = fileList.flatMap(x=>x.split(" "))
    println("flatMapList "+flatMapList)

    val result: List[(String, Int)] = flatMapList.groupBy(x=>x).map(t=>(t._1,t._2.size)).toList.sortWith((left,right)=>(left._2>right._2))
    println("result "+result)

  }

}

package chapter03

import scala.collection.{GenTraversableOnce, mutable}
import scala.collection.immutable.StringOps

object test09 {

  def main(args:Array[String]):Unit={


    //TODO wordCount
    val linesList = List(("hello scala world",4),("hello world",3),("hello python",2),("hello hadoop",1))

    //1.拆分数据
    //("hello scala world",4) ==>(hello,4),(scala,4),(world,4)
    val flatMapList: List[(String, Int)] = linesList.flatMap(t => {
      val line = t._1
      val words = line.split(" ")
      words.map(w => (w, t._2))
    })
    println("flatMapList "+flatMapList)

    val groupWordMap: Map[String, List[(String, Int)]] = flatMapList.groupBy(x=>x._1)
    println("groupWordMap "+groupWordMap)

    //2.1 将分组后得数据进行结构转换
    val wordToSumMap: Map[String, Int] = groupWordMap.map(t => {
      val countList: List[Int] = t._2.map(x => x._2)
      (t._1, countList.sum)
    })
    println("wordToSumMap "+wordToSumMap)

    //2.1 mapValues可以只针对Map集合中的Value操作，Key保持不变
    val wordToSumMap2: Map[String, Int] = groupWordMap.mapValues(datas=>datas.map(tt=>tt._2).sum)
    println("wordToSumMap2 "+wordToSumMap2)

    //2.3 排序
    val wordSortList: List[(String, Int)] = wordToSumMap.toList.sortWith((left,right)=>left._2>right._2)
    println("wordSortList "+wordSortList)


    val takeList: List[(String, Int)] = wordSortList.take(4)
    println("takeList "+takeList)



  }

}

 

package chapter03

object test10 {
  def main(args:Array[String]):Unit={
    //集合内部
    //将集合的数据经过逻辑处理后保留一个结果，具体的结果需要参考逻辑实现

    val list = List(1,2,3,4)
    //( (1+2)+3 ) +4
    //val sum: Int = list.reduce((left,right)=>{left+right})
    val result: Int = list.reduce(_+_) //10

    //reduceLeft
    val result2: Int = list.reduceLeft(_+_) //10  ( (1+2)+3 ) +4
    val result3: Int = list.reduceLeft(_-_) //-8  ((1-2)-3 )-4



    //reduceRight
    //reversed ==> 4,3,2,1
    //reduceLeft==>((4-3)-2)-1
    //reduceRight==>1-(2-(3-4))
    val result4: Int = list.reduceRight(_+_)//10   1+(2+(3+4))
    val result5: Int = list.reduceRight(_-_)//-2    1-(2-(3-4))



    println(result)
    println(result2)
    println(result3)
    println(result4)
    println(result5)



  }

}

package chapter03

object test11 {
  def main(args:Array[String]):Unit={
    //外部元素与集合内部元素的运算
    val list = List(1,2,3,4)
    //fold方法可以传递2部分参数，第一部分表示集合外的元素，第二部分表示集合内部的元素进行逻辑处理
    //( (100+1)+2)+3 )+4
    val result: Int = list.fold(100)(_+_) //110

    val result2: Int = list.foldLeft(100)(_+_) //110
    val result3: Int = list.foldRight(100)(_+_)//110

    //(((100-1)-2)-3)-4
    val result4: Int = list.foldLeft(100)(_-_)//90
    //reversed=>4,3,2,1
    //foldRight 1-(2-(3-(4-100)))
    val result5: Int = list.foldRight(100)(_-_)//98
    println(result)
    println(result2)
    println(result3)
    println(result4)
    println(result5)

  }

}