scala-day02_ (函数，集合，元组，map集合)

scala (函数，集合，元组，map集合，单词统计)

scala面向函数编程，lambda表达式

package com.wt.day02
import scala.language.postfixOps

/**
 * @author WangTao
 * @date 2022/7/8 18:00
 */
object Demo11Fun {
  def main(args: Array[String]): Unit = {
    /**
     * 面对对象编程 - 将对象穿来穿去
     * 1. 以对象作为参数
     * 2. 以对象作为返回值
     * 需要明确参数的类型，返回值的类型和对象的类型 - 可以使用多态(父类的引用指向子类的对象)
     *
     * 面向函数编程， - 将函数传来传去 - 高阶函数
     * 1. 以函数作为参数 (必须要很熟练)
     * 2. 以函数作为返回值，(了解)
     *
     * 函数的类型 = 由参数的类型和返回值类型决定
     * strToInt 是一个参数为String 返回值为Int类型的函数
     *
     * 函数类型的表示 ：String => Int 前面的是参数类型，后面的为返回值类型
     *
     */
    def strToInt(str: String): Int={
      str.toInt
    }

    val i: Int = strToInt("1000")
    println(i)

    //scala中函数也是一个对象，可以改变引用
    val strToStringTemp: String => Int = {
        strToInt
    }

    val j: Int = strToStringTemp("200")
    println(j)

    print("="*100)

    /**
     * 1. 函数作为参数
     *
     * fun的参数是一个函数，(是一个参数为String返回值为Int类型的函数)
     *
     * 以函数作为参数编程的作用--- 我们可以将一个代码逻辑中需要变化的部分抽象出来，让调用者以函数的形式传递进来
     */

    //定义一个参数为函数的函数
    def fun(f:String => Int): Unit ={
      println("执行fun函数")
      //调用传进来的函数
      println("调用f")
      val i: Int = f("100")
      println(i)
    }

    //f1是一个参数为String 返回值为Int类型的函数
    def f1(str: String): Int = {
      println("执行f1")
      str.toInt
    }
    println("调用fun函数")
    fun(f1)

    def fun2(str: String):Int = {
      str.toInt +666
    }
    fun(fun2)
    /**
     * lambda 表达式 (匿名函数：没有名字的函数)
     * (s:String)=> s.toInt
     *
     *前面是参数，后面是函数体和返回值，默认最后一行作为返回值
     *
     * lambda表达式返回值的类型会自动推断
     */
    //使用lambda表达式作为函数的参数
    fun((str: String) =>{
      str.toInt
    })
    //函数只有一行时可以省略括号
    fun((str: String) => str.toInt)
    //lambda表达式的参数类型可以自动推断
    fun(f => f.toInt)
    //如果参数只使用了一次可以使用下划线代替
    fun(_.toInt)
  }
}

scala中的foreach

package com.wt.day02

/**
 * @author WangTao
 * @date 2022/7/8 18:49
 */
object Demo12Fun {
  def main(args: Array[String]): Unit = {
    /**
     * 以函数作为参数的应用
     */
    val array: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8)

    /**
     * foreach:循环数组中的元素一个一个传递给后面的函数
     *
     * Any:相当于Java中的object
     */
    def f(i: Int): Unit = println(i)

    array.foreach(f)

    println("=" * 100)

    //lambda表达式
    array.foreach((i: Int) =>println(i))
    println("=" * 100)
    //简写
    array.foreach(i => println(i))
    println("=" * 100)
    //简写
    array.foreach(println(_))
  }

}

scala函数作为返回值，函数函数柯里化

package com.wt.day02
/**
 * @author WangTao
 * @date 2022/7/8 19:03
 */
object Demo13Fun {
  def main(args: Array[String]): Unit = {
    /**
     * 2. 以函数作为返回值
     *
     */
    //这么写没有任何意义，只是表名函数可以即作为参数又可以返回值
    def fun(f: String => Int): String => Int ={
      println("fun")
      f
    }

    /**
     *   fun参数和返回值都是哟个函数
     *   参数为一个参数为String返回值为Int类型的函数
     *   返回值为一个参数为String返回值为Int类型的函数
     *
     */

    val function:String => Int =fun((s:String) => s.toInt)

    def fun1(str: String):String => Int = {
      //定义一个参数为String返回值为Int类型的函数
      def f(s: String): Int={
        //在函数内使用函数外的变量叫做 闭包
        s.toInt + str.toInt
      }
      //返回一个函数
      f
    }

    //调用fun1函数，传入一个字符串
    val stringToInt: String => Int = fun1("100")
    println(stringToInt)
    //再次调用返回的函数，再次传入一个字符串
    val i: Int = stringToInt("20")
    println(i)

    //简化fun1函数调用的过程
    val i1: Int = fun1("66")("22")
    println(i1)

    /**
     *  简写上面的函数 --函数柯里化
     */

    def fun2(str:String)(s:String): Int ={
      str.toInt + s.toInt
    }

    val i2: Int = fun2("1000")("2")
    println(i2)

    //可以先传递一个参数，后面的参数可以传递很多次，提高了代码的复用性
    val fun3: (String => Int) = fun2("100")

    println(fun3("1"))
    println(fun3("2"))
    println(fun3("3"))
    println(fun3("4"))

    /**
     * 偏应用函数
     *
     */
    //调用函数的时候可以直传一部分参数，返回一个函数，调用返回的函数后，在传一部分的函数
    //下划线是占位符的作用
    val fun5: String => Int = fun2("1")(_)
    println(fun5("2"))
    println(fun5("3"))
    println(fun5("4"))
    println(fun5("5"))
  }
}

scala 中使用Java中的集合

package com.wt.day02
import java.util
/**
 * @author WangTao
 * @date 2022/7/8 19:38
 */
object Demo14JavaList {
  def main(args: Array[String]): Unit = {
    /**
     * 在Scala中可以使用Java的集合
     */
    val list: util.ArrayList[Int] = new util.ArrayList[Int]

    list.add(1)
    list.add(3)
    list.add(5)
    list.add(6)
    list.add(9)
    println(list)
    //通过下标获取到对应的值
    println(list.get(3))
    /*
        增强for循环本质上是使用迭代器进行循环
        Scala和Java使用的是不同的迭代器，所有java的集合在scala语言中不能使用增强for循环进行遍历
     */

    //可以使用以下的迭代器
    var i = 0
    while(i < list.size()) {
      println(list.get(i))
      i += 1
    }
  }

}

scala 中的List集合(重点)

package com.wt.day02
/**
 * @author WangTao
 * @date 2022/7/8 19:56
 */
object Demo15List {
  def main(args: Array[String]): Unit = {
    /**
     * scala集合
     * 1. List：有序，不唯一
     * 2. Set:  无序，唯一
     * 3. Map:  kv格式，key是唯一的
     * 4. Tuple:元组，固定长度的集合
     */
    /**
     * List集合
     * Scala的集合比Java的集合好用了很多的方法
     */
    //不可变的List
    val list = List(1, 2, 3, 4, 5, 6, 7, 6, 4, 2)
    //通过下标获取元素
    println(list(3))
    //获取第一个元素
    println(list.head)
    //获取最后一个元素
    println(list.last)
    //获取不包含第一个的所有的元素
    println(list.tail)
    //将集合中的元素拼接成一个字符串
    val str: String = list.mkString("|")
    println(str)
    //反转，返回一个新的list
    println(list.reverse)
    //取前面n个元素
    println(list.take(4))
    //取后面几个元素
    println(list.takeRight(4))
    //去重
    println(list.distinct)
    //求和，集合元素的类型必须是可以求和的类型
    println(list.sum)
    //取最大值
    println(list.max)
    //取最小值
    println(list.min)

    println("=" * 100)

    /**
     * foreach : 循环集合，将集合一个一个传递给后面的函数，foreach没有返回值
     *
     */
    def pr(i: Int): Unit = println(i)
    list.foreach(pr)

    list.foreach((i:Int)=>println(i))

    //方式二
    var sum = 0
    //循环统计总和
    list.foreach((i: Int) =>{
       sum += i
    })
    println(sum)

    println("=" * 100)
    /**
     * 给每一个元素添加一(处理集合中的元素)
     */
    for (elem <- list) {
      println(elem +  10)
    }

    /**
     * map:循环集合,将集合中的元素一个一个传递给后面的函数，函数的返回值构建出一个新的函数
     * i:代表的是结合中的所有元素
     */
    println("=" * 100)
    val list1: List[Int] = list.map((i: Int) => i + 1)
    println(list1)

    println("=" * 100)

    /**
     * 处理集合中的元素，偶数加1，奇数乘以2
     */
    val list2: List[Int] = list.map((i: Int) => {
      if (i % 2 == 1) {
        i * 2
      } else {
        i + 1
      }
    })
    println(list2)

    /**
     * 取出集合中的奇数
     * Filter:循环集合，将集合中的元素一个一个传递给后面的函数
     * 如果函数为true保留数据，如果函数返回false则过滤数据
     */
    val list3: List[Int] = list.filter((i: Int) => i % 2 == 1)
    println(list3)

    println("=" * 100)
    /**
     * 将一行中的多个单词拆分出来，一个单词占一行
     */
    val lineList: Seq[String] = List("java,spark,hadoop","datax,scala,java", "hadoop,hive,sqoop")
    for(line <- lineList){
      val split: Array[String] = line.split(",")
      for (word <- split) {
        println(word)
      }
      //或者这样写
      line.split(",").foreach((str: String) => println(str))
    }
    println("=" * 100)

    /**
     * flatmap:循环集合中的函数，将函数一个一个传递给后面的函数
     * 函数返回一个集合，flatmap会将返回的集合拆分出来构建成一个新的集合
     */
    val strings: Seq[String] = lineList.flatMap((str: String) => str.split(","))
    strings.foreach((s:String) => println(s))

    println("=" * 100)

    /**
     * 多集合排序
     * sortBy:需要指定一个排序的字段，默认是升序
     * sortWith：指定一个排序的比较规则
     */
    val list4 = List(1, 2, 4, 5, 7, 8, 5, 4, 34, 65, 67, 33, 454, 666, 456, 345, 345)
    //如果是-i就是降序，如果是 i就是升序
    val ints: List[Int] = list4.sortBy((i: Int) => -i)
    ints.foreach(println)

    println("=" * 100)

    /**
     * groupBy:分组，需要指定分组的字段
     */
    val words = List("java", "spark", "java", "java", "spark", "hadoop")
    val groupByList: Map[String, List[String]] = words.groupBy((word: String) => word)
    groupByList.foreach(println)
  }
}

scala 中的set集合

package com.wt.day02
/**
 * @author WangTao
 * @date 2022/7/8 21:28
 */
object Demo16Set {
  def main(args: Array[String]): Unit = {
    /**
     * Set集合，无序，唯一
     * set集合比List集合少了排序的方法，其它的方法基本一致
     */
    val set = Set(1, 2, 3, 4, 5, 6, 7, 8, 9)
    println(set)
    println(set.mkString("\t"))
    set.foreach(println)

    println("=" * 100)

    val s1 = Set(1, 2, 3, 4, 5)
    val s2 = Set(3, 4, 5, 6, 7)
    println(s1 & s2) //交集
    println(s1 | s2) //并集
    println(s1 &~ s2) //差集

    /**
     * 集合之间的相互转换
     */

    val list = List(1, 2, 2, 3, 2, 1, 2, 4, 5, 6, 7, 8)
    println(list)
    println("==========================")
    val set1: Set[Int] = list.toSet
    set.foreach(println)
  }
}

scala 中的可变集合

package com.wt.day02
import scala.collection.mutable
import scala.collection.mutable.ListBuffer
/**
 * @author WangTao
 * @date 2022/7/8 21:34
 */
object Demo17Mutable {
  def main(args: Array[String]): Unit = {
    /**
     * 可变集合
     * ListBuffer:List有的方法ListBuffer都有，只是ListBuffer是可以改变的
     *
     */
    val listBuffer = new ListBuffer[String]
    //增加元素
    listBuffer.+=("java")
    listBuffer +=("hadoop")
    listBuffer +=("scala")
    listBuffer +=("linux")
    listBuffer +=("flume")
    println(listBuffer)

    //删除元素
    listBuffer -= ("java")
    println(listBuffer)

    //使用下标删除元素
    listBuffer.remove(3)
    println(listBuffer)

    //批量添加元素
    listBuffer ++= List("dfaag","SDFF","sdgafa")
    println(listBuffer)

    //更新元素
    listBuffer.update(2,"哮天犬")
    println(listBuffer)

    /**
     * 可变Set
     *
     */

    val hashSet = new mutable.HashSet[Int]()

    //增加元素
    hashSet += 1
    hashSet += 2
    hashSet += 3
    hashSet += 4
    hashSet += 5

    println(hashSet)

    //删除元素
    hashSet -= 1
    println(hashSet)
  }
}

scala 中的元组

package com.wt.day02
/**
 * @author WangTao
 * @date 2022/7/8 21:42
 */
object Demo18Tuple {
  def main(args: Array[String]): Unit = {
    /**
     * 元组：固定长度集合
     * 可以通过下划线加上下标获取数据, 可以避免下标越界异常
     *
     * 元组最多只能存22个元素
     */
    //val tuple: (Int, Int, Int, Int, Int, Int) = Tuple6(1, 2, 3, 4, 5, 7)

    //简写
    val tuple = (1,2,3,4,5,6)
    println(tuple._4)
  }
}

scala 中的map集合

package com.wt.day02
import scala.collection.mutable
/**
 * @author WangTao
 * @date 2022/7/8 21:52
 */
object Demo19Map {
  def main(args: Array[String]): Unit = {
    /**
     * map：kv格式的集合
     *
     */
    val map: Map[String, Int] = Map(("001", 23), ("002", 24), "003" -> 25)
    println(map)
    //可以通过key获取value
    val value: Int = map("002")
    println(value)

    //如果不存在key就返回默认值
    val age: Int = map.getOrElse("004", 0)
    println(age)

    /**
     * 给每一个人的年龄加一
     *
     * map集合的map方法，函数的参数是哟个二元组
     *
     * 返回一个新的map
     */

    val addAge: Map[String, Int] = map.map((kv: (String, Int)) => {
      val id: String = kv._1
      val age: Int = kv._2
      (id, age + 1)
    })
    println(addAge)

    /**
     * 可变map集合
     */
    val hashMap = new mutable.HashMap[String, String]

    //插入元素
    hashMap += "001" -> "张三"
    hashMap += "002" -> "李四"
    hashMap += "003" -> "王五"
    println(hashMap)

    //如果key存在自动覆盖
    hashMap += "003" -> "赵六"
    println(hashMap)

    //删除元素
    hashMap.remove("003")
    hashMap -= "002"
    println(hashMap)

  }
}