Scala_day2

package com.song.scala.day02

import scala.collection.mutable

object Test02 {
  def main(args: Array[String]): Unit = {
    val arrs = Array(1, 23, 4, 5)
    val arrmap = arrs.map(x => x)
    println(arrmap.toBuffer)
    arrmap.foreach(println)
    /*
    集合：是一种用来存储各种数据的容器
    scala集合可以分为可变和不可变的集合，不可变集合可以安全的并发方法
    可变集合可以在适当的地方被更新或扩展。这意味着可以修改，添加 移除一个集合的元素
    不可变集合，相比之下，永远不会改变。不过你仍然可以模拟添加,移除或更新操作。但是这些操作将在每一种情况下都返回一个新的集合，同时是原来的集合不会发生改变
     scala集合两个主要的包：
     不可变集合：scala.collention.immutable
     可变集合：scala.collection.mutable,scala默认采用不可变集合
     scala的集合有三大类：序列Seq,集Set,映射Map,所有的集合都扩展自iterable特质

     */


    //数组
    //    数组元素要求类型一致
    //定长数组，数组不可扩容
    //变长数组，数组可扩容
    val array = new Array(4) //长度
    val arr = Array(1, 2, 3)

    //变长数组需引入包
    import scala.collection.mutable.ArrayBuffer
    val muta = ArrayBuffer[Int]()
    muta.append(1)
    muta += 3
    muta += (6, 2)
    muta.insert(34, 45) //第一个为下标
    muta.remove(0, 2) //0开始移除两个

    //yield 将函数的返回值封装其他类型
    val res = for (i <- muta if i % 2 == 0) yield i * 10

    muta.filter(x => x % 2 == 0).map(x => x * 10)

    //paixu
    muta.sortWith((x, y) => x < y)
    muta.sortWith(_ > _)
    muta.sortBy(x => x)

    val arr4 = Array(("a", 3), ("b", 1), ("c", 2))
    val sotedArr = arr4.sortBy(_._2) //按第二个元素排序
    val sortedarr = arr4.sortWith(_._2 > _._2)
    println(sortedarr.toBuffer)
    //映射（Map） （重要）
    //    在scala中,把哈希表这种数据结构叫做映射
    //    scala中的Map存储的内容是键值对（key-value），Scala中不可变的map是有序的，可变的的Map是无序的
    //    Scala,有可变Map(scala,collection,mutable,Map)和不可变Map（scala.collection.immutable.Map）
    //构建映射
    //    在Scala中，有两种Map,一个是Immutable包下的Map,该MAP中的内容不可变，另一个是mutable包下的Map,该Map下的内容可变

    val user = Map(("tim", 4), ("herry", 8), ("shuke", 5))
    val godden = Map(("tim" -> 4), ("herry" -> 8), ("shuke" -> 5))

    //可变的
    import scala.collection.mutable.Map
    val god = Map(("tim" -> 4), ("herry" -> 8), ("shuke" -> 5))
    god += ("beta" -> 4, "tik" -> 9)
    //删除
    god -= ("beta")
    god.remove("tik")
    //遍历
    for ((key, value) <- god) println(key + "---------" + value)
    for (v <- god.values) println("---------" + v)
    for ((key, value) <- god) yield (key, value) //yield 封装前面的值
    new mutable.LinkedHashMap[String, Int]

    //元组
    val tup = ("fdsf", true)
    tup._1 //元组是从1开始的
    //元组的声明的第二种方式
    val tup1 = new Tuple1(3) //1是一种类型

    /*val tup,(a,b,c)=(1,2,3)
    //取值
    a
     */
    val str = tup.toString()
    tup.swap //交换两个数字的位置

    //拉链操作
    val arr1 = Array(53, 56, 78)
    val arr2 = Array(34, 54, 22)
    //    arr1 zip  arr2      //长度较长的直接截掉
    //  （arr1 zip  arr2）.map(x=>x._1+x._3)  //将zip后的数据add


    //    List列表：可变和不可变
    //    一个列表要么为空，要么为head元素加tail的列表
    val seq = Seq(1, 2, 3, 4)
    val list = Seq(43, 4, 7)
    //加进去
    8 :: List(3, 4)
    3 :: 5 :: Nil //Nil为空的列表，所以会生成一个列表
    //加新的元素
    seq :+ Array(3, 4, 6)
    //将另一个list加入另一个
    val ints = List(34, 45, 75)
    val lists = list ++ seq

  //可变的
    import  scala.collection.mutable.ListBuffer
    val listb=ListBuffer[Int]()
    listb+=1
    listb+=2
    //声明2
    var listb2 = new ListBuffer[Int]
    listb2.append(34)

    //list加到另一个list2
    list++listb2  //生成一个新的列表
    //后面追加
    listb2:+=5

    //set 无序 不重复  可变不可变

    //不可变
    val set=Set(3,43,5)
    //加数据
    set+56
    val set1=Set(56,78,97)
    set++set1
    set.getClass  //返回什么类型
    //可变的
    val set2 = new mutable.HashSet[Int]()
    set2+=45
    set2+=455
    set2-=45
    set2.remove(455)

    //intersect  diff  union  并交差





  }

  def m1(x: Int): Int = {
    //方法中，会将最后一行代码的值最为返回，但是，如果赋值的过程，是不能作为返回值
    val sum = x * x
    sum

  }


}

懒加载 java and scala

package com.song.scala.day02;

/**
 * 一般是单例模式的懒汉模式
 */
public class LazyDemo {
    private static MyProperty prop;

    public static MyProperty getProp() {
        if (prop == null) {
            prop = new MyProperty();
            System.out.println("getProperty"+prop);
        }
        return prop;
    }

    public static void main(String[] args) {


    }
}

class MyProperty {

}

package com.song.scala.day02

class  ScalazyDemo{

}
object ScalazyDemo1 {

  def init():Unit={
    println("init")
  }

  def main(args: Array[String]): Unit = {
    val  prop=init(); //没有使用lazy修饰符

    println("after init")

    println(prop)

  }
}


object ScalazyDemo2 {

  def init():Unit={
    println("init")
  }

  def main(args: Array[String]): Unit = {
     lazy val  prop=init(); //没有使用lazy修饰符

    println("after init")  //第一步执行

    println(prop)

  }
}

练习

package com.song.scala.day02

object test_2 {
  def main(args: Array[String]): Unit = {
    //创建一个List
    val list1 = List(1, 2, 3, 4, 5, 6, 8)

    //将list1中每个元素乘以二
    val list0 = list1.map(x => x * 2)

    //将list1中偶数取出形成新的集合
    val list2 = list1.filter(x => x % 2 == 0)

    //排序形成新的集合
    val list3 = list1.sorted //默认升序 降序reverse
    val list4 = list1.sortBy(x => x)
    val list5 = list1.sortWith((x, y) => x > y)
    //反转排序
    val list6 = list1.sorted.reverse
    //将list1中的元素4个一组，类型为Iterator
    val iterator: Iterator[List[Int]] = list1.grouped(4)
    //将iterator转换为list
    val list7: List[List[Int]] = iterator.toList
    //将多个list压扁为一个
    val list8=list7.reduce((x,y)=>x:::y)   //::: 表示两个元素集合
    println(list8)
        //--reduce函数
    val flatten = list7.flatten
    println(flatten)

    //每个字符串按空格切分，再压平

    val lines = List("hello tim  hello jerry", "Hello  suke hello")
    val wordsarr = lines.map(x=>x.split(" "))
  //  println(wordsarr.map(_.toBuffer))  //list里有多个arrayBuffer,所以我们直接可以将切分的flatten
    val word = wordsarr.flatten
    println(word)
    //flatmap
    val word2=  lines.flatMap(x=>x.split(" "))  //先map再flat
    println(word2)
      
       //    ---------------------------------------------
    //并行计算求和     //并发：同一时间段
    val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    /* println(arr.sum)  //数组求和
     println(arr.reduce((x, y) => x + y))
     println(arr.reduce(_ + _))  //reduceleft  单线程操作
    */
    //    按照特定的顺序
    println(arr.reduceLeft(_ + _))
    //多线程累加
    println(arr.par.reduce(_ + _)) //  想减时就结果不同了
    while (true) {
      val i: Int = 1                //根据线程数值也不一样
      println((arr).reduce(_ - _))
    }

    //折叠（fold）：有初始值（无特定顺序）
    println(arr.fold(0)(_ + _))   //第一参数 是初始值
    //折叠：有初始值（有特定顺序）
    arr.par.foldLeft(10)(_+_)   //当调用特定排序顺序时，此时多线程不起作用

    //聚合
    val arr1=List(List(2,3,4),List(3,4,5),List(6,7,8))
    println(arr1.reduce((x, y) => List(x.sum + y.sum)))
    //  def aggregate[B](z : => B)(seqop : scala.Function2[B, A, B], combop : scala.Function2[B, B, B]) : B = { /* compiled code */ }
    /*
    第一参数代表初始值
    第二个参数列表的第一个参数,局部聚合（线程内聚合）
    第三个参数列表的第二个参数，全局聚合（线程间聚合）
     */
    val sum: Int = arr1.flatten.sum
     arr1.aggregate(0)(_+_.sum,_+_)  //初始值为0

  //求聚合值，arr sum and   arr nums
    val arr2=Array(1,2,3,45,6,7)
    arr2.aggregate((0,0))  ((x,y)=>(x._1+y,x._2+1),  (m,n)=>(m._1+n._1,m._2+n._2))


  }

}

WordCount

package com.song.scala.day02

object WordCount {
  def main(args: Array[String]): Unit = {
    val lines = List("hello tim  hello jerry", "Hello  suke hello")
    //将数据切分，生成一个个单词

    val word: List[String] = lines.flatMap(x => x.split(" "))

    //将空字符串过滤
    val words = word.filter(!_.isEmpty)
    //将每个单词生成一个元组（word,1)
    val tuples: List[(String, Int)] = words.map((_, 1))

    //将相同的单词进行分组
    val grouped: Map[String, List[(String, Int)]] = tuples.groupBy(_._1)
    //将相同单词的数据进行个数统计
    //  val sumd: Map[String, Int] = grouped.map(x=>(x._1,x._2.size))
    val sumd = grouped.mapValues(_.size) //只操作value key留着呢
    println(sumd)

    //降序排序  map，list是没有排序的方法的
    val sorted: List[(String, Int)] = sumd.toList.sortBy(_._2)
    println(sorted)


  }
}

 //一句代码计数
lines.flatMap(_.split(" ")).filter(!_.isEmpty).map((_,1)).groupBy(_._1).mapValues(_.size).toList.sortBy(_._2)