scala----常用方法 类的定义

常用方法

1. 聚合常用函数
sum     求和 , 底层是调用的foldLeft

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

    val lst: Seq[(String, Int)] = List(("hadoop",3) , ("fink",5) , ("spark",2) , ("hadoop",3),("fink",6))
    //根据单词分组
    val grouped = lst.groupBy(_._1)
    //a._1为单词  a._2为List集合 _._2取个数求和
    val word = grouped.map(a => (a._1, a._2.map(_._2).sum))
    println(word)
  }
}

reduce  arr.reduce(_+_)     聚合函数 , 底层调用的是reduceLeft
reduceLeft (_+_)     比reduce更加灵活  原理是第一个元素加第二个元素之和为第一个参数,第三个元素为第二个参数,一次相加
_代表数据类型
fold(n)(_+_) 55   fold(100)(_+_) 155   fold(1000)(_+_) 1055   第一个括号是指定了起始值
foldLeft(n)(_+_)    数据类型可以不相同 更加灵活

//  foldLeft小案列
object FoldDemo {
  def main(args: Array[String]): Unit = {

    val lst: Seq[(String, Int)] = List(("hadoop",3) , ("fink",5) , ("spark",2) , ("hadoop",3),("fink",6))

    //根据单词进行分组
    val grouped: Map[String, Seq[(String, Int)]] = lst.groupBy(_._1)
    //使用doldLeft代替sum第一种方法  第一个_代表List,第二个_代表foldLeft的初始值
//    val stringToInt = grouped.mapValues(_.foldLeft(0)(_ + _._2 ))
//    println(stringToInt)
    // 使用foldLeft代替sum第二种方法
    val word: Map[String, Int] = grouped.map(b => (b._1, b._2.foldLeft(0)((x, y) => x + y._2)))
    println(word)
  }
}

product    相乘

2. 排序方法
Sorted      升序
Sorted(ordering[Int].reverse)     倒序
nums.sortBy(x=>x)     排序 更加灵活  括号中的函数可以改变排序规则,不可以改变数据类型
SortWith(_>_)     降序
SortWith(_<_)     升序

3. 数组中取元素方法
take(n)     从数组中取n个元素,返回的是数组, 从头开始不排序
takeRight(n)     数组中从尾部取n个元素
takeWhile(条件表达式)     从前面开始取,渠道不满足条件的位置,如果第一个就不满足条件,就一个都不取
aggregate()()

4. 最大小值
arr.reduce.Math.min(_,_)     数组中两数相比取最小,求数组最大值
arr.reduce.Math.max(_,_)    数组中两数相比取最大,求数组最大值

5. par    是个方法,并行化集合

package cn.doit.com.day02.demo04

import scala.collection.parallel.ParSeq

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

    val lst = List(1,3,5,7,3,8,9,6)

    //parallel 并行化集合
    val parList: ParSeq[Int] = lst.par

    //元素和
    //val r = parList.sum

    //并行化集合,将集合分成n份,每一个线程计算一部分
    val r = parList.fold(100)(_+_)
    println(r)

    //线城时第二个参数才有用处,集合par使用
    val i = parList.aggregate(0)(_ + _, _ * _)
    println(i)
  }
}

6. mapValues   对值进行操作,再跟值拼接

package cn.doit.com.day02.demo03
/*
    MapValues
      对k,v的数据进行处理
      对values进行处理,并且将处理的结果分k在组合成一个元组
 */
object MapValuesDemo {
  def main(args: Array[String]): Unit = {
    val lines = Array("hadoop,flink,spark,hadoop,Hive","hadoop,Flink,spark,Hadoop,spark")

    val grouped = lines.flatMap(a => a.split(",")).groupBy(b => b.toLowerCase())
    //原来为了计数, k拿出来什么都没做
    //grouped.map(c => (c._1 , c._2.length))
    //mapValues将values进行map操作,然后再和key组合成一个元组
    val tuples = grouped.mapValues(c => c.length).toList.sortBy(-_._2)
    println(tuples)
  }
}

类的定义

类和半生对象中的属性和方法都可以用访问权限修饰符修饰
类和半生对象可以相互访问private修饰的变量和方法
private[this]如果在类中定义,就只能在类的内容使用
private[this]如果在类中定义,就只能object的内容使用

package cn.doit.com.day02.demo02
/*
  类和伴生对象中的属性和方法都可以用访问权限修饰符修饰
  类和伴生对象可以相互访问private修饰的变量和方法
  private[this]如果在类中定义,就只能在类的内容使用
  private[this]如果在object中定义,就只能当前的object中使用

  类前面加上private就是包访问权限,在当前包和子包中可以访问
  在类名后面加的private是私有的构造器,只能在半生对象中访问
 */

//private[day02]包访问权限,只能在day02包及其子包中访问
//private[day02] class User {
//类名后面加的private为私有的无参构造器,只能在伴生对象中使用
  class User private {

  var name: String = _
  //在scala中,如果用private修饰的成员变量,在其他类或者object中就无法访问了
  //private修饰的成员变量只能在类中或者半生对象中使用
  private var age: Int = _
  //对象私有手段,访问权限更加严格,只能在类的内部使用[在实例的内部使用]
  private[this] var sal = 12000

  def printAge():Unit={
    println(age)
    println(sal)
  }
  def printSal():Unit={
    println(sal)
  }
}
/*
    伴生对象
    1.使用object定义,object的名字和类名一致
    2.object和class在同一个.class文件中
 */
object User{
  def main(args: Array[String]): Unit = {
    val user = new User
    user.name = "wgg"
    user.age = 28

    user.printAge()
  }
}