scala(五)集合

1.数组

new Array后面需要加个泛型 赋值时（）而不是[]

数组定义、数据的修改、多种遍历

（1）数组定义
        val arr01 = new Array[Int](4)
        println(arr01.length) // 4

        //（2）数组赋值
        //（2.1）修改某个元素的值
        arr01(3) = 10
        val i = 10
        arr01(i/3) = 20
        //（2.2）采用方法的形式修改数组的值
        arr01.update(0,1)

        //（3）遍历数组
        //（3.1）查看数组
        println(arr01.mkString(",")) 

        //（3.2）普通遍历
        for (i <- arr01) {
            println(i)
        }

        //（3.3）简化遍历
        def printx(elem:Int): Unit = {
            println(elem)
        }
        arr01.foreach(printx)    //将arr01中的数据拿出来放到foreach遍历
        arr01.foreach((x)=>{println(x)})
        arr01.foreach(println(_))
        arr01.foreach(println)
    }
}

多维数组、数组合并、创建指定范围的数组

//多维数组
val array: Array[Array[Int]] = Array.ofDim[Int](3,2)
  array.foreach(Array => println(Array.mkString(",")))
0,0
0,0
0,0
//数组合并
val arr1 = Array(1,2,3,4)
    val arr2 = Array(5,6,7,8)
    val ints: Array[Int] = Array.concat(arr1,arr2)
    ints.foreach(println(_))
//创建指定范围的数组
 val ints: Array[Int] = Array.range(1,5,2) //1到5 不包括5 2为步长   1 3
    ints.foreach(println(_))

2.集合中常用方法

计算相关的方法

功能函数： 由集合对象提供函数执行自定义的功能

map => 映射（转换） a=> b 将集合中的每一条数据进行处理

val arr2: ArrayBuffer[Int] = ArrayBuffer(1,2,3,4)
    val ints1: ArrayBuffer[Int] = arr2.map(num => num*2)
    println(ints1)

将整体拆分成个体的操作，称之为扁平化

扁平化操作只能对最外层进行操作

flatten flatMap :自定义扁平化 将集合中的每个整体扁平化

val strings: ArrayBuffer[String] = ArrayBuffer("hello world","hello scala")
    val strings1: ArrayBuffer[String] = strings.flatMap(str => {
      str.split(" ")
    })
    println(strings1)

filter

filter方法可以对集合中的每一条数据进行筛选过滤

满足条件(true)的数据保留，不满足条件(false)的数据丢弃

  val ints: ArrayBuffer[Int] = arr.filter(num => {
      num % 2 != 0
    })
    println(ints)

reduce 聚合两个值变一个

 val arr2: ArrayBuffer[Int] = ArrayBuffer(1,2,3,4)
    arr2.reduce((x:Int,y:Int)=>{x+y} )

groupby 按照一定规则分组

val arr2: ArrayBuffer[Int] = ArrayBuffer(1,2,3,4)
  val booleanToInts= arr2.groupBy(num => {
      num % 2
    })

  val arr3: ArrayBuffer[String] = ArrayBuffer("hello","scala","hadoop","spark")
    val stringToStrings: Map[String, ArrayBuffer[String]] = arr3.groupBy(str => {
      str.substring(0, 1)   //分组规则
    })

sortBy 通过指定的规则对每一条数据进行排序处理 默认为升序

 val strings2: ArrayBuffer[String] = ArrayBuffer("1","2","22","11")
    println(strings2.sortBy(str => str.toInt))
ArrayBuffer(1, 2, 11, 22)
    val strings2: ArrayBuffer[String] = ArrayBuffer("1","2","22","11")
    println(strings2.sortBy(str => str.toInt)(Ordering.Int.reverse))   //函数柯里化  中间的int是可变的  看你是什么类型
ArrayBuffer(22, 11, 2, 1)

word count案例

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

        // TODO 1. 读取文件，获取原始数据
        //  line => Hello Scala
        val source: BufferedSource = Source.fromFile("data/word.txt")
        val lines: Array[String] = source.getLines().toArray
        source.close()

        // TODO 2. 将原始数据进行切分成一个一个的单词
        // "Hello Scala" => "Hello", "Scala"
        val words = lines.flatMap(
            line => {
                line.split(" ")
            }
        )

        // TODO 3. 对分词的结果进行分组操作（相同的单词放置在一起）
        // "Hello", "Hello" => { "Hello"=>List( Hello, Hello ) }
        val wordGroup: Map[String, Array[String]] = words.groupBy(word => word)

        // TODO 4. 对分组后的数据进行数量的统计
        // 如果数据在转换时，无需对key进行操作，只对v进行处理时，可以使用mapValues方法
        // { "Hello"=>List( Hello, Hello ) }
        // =>
        // { "Hello"=>2 }
        val wordCount = wordGroup.mapValues(
            v => {
                v.size
            }
        )

        // TODO 5. 将统计结果打印在控制台
        println(wordCount)

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

        // TODO 1. 读取文件，获取原始数据
        //  line => Hello Scala
        val source: BufferedSource = Source.fromFile("data/word.txt")
        val lines: Array[String] = source.getLines().toArray
        source.close()

        val wordCount =
            lines
                .flatMap(_.split(" "))
                .groupBy(word => word)
                .mapValues(_.size)

        println(wordCount)

    }

2.元组

scala可以将无关的元素组合在一起，形成一个整体来进行访问，这种整体结构称之元素组合，称为元组