scala学习day04

1.模式匹配

package com.shujia.scala

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

    /**
      * 在java中模式匹配，只能匹配（基本数据类型，字符串，枚举）
      *
      * scala中的模式匹配 可以匹配基本数据类型，字符串，枚举，对象，类型
      *
      */

    val str: String = "男"

    /**
      * 模式匹配：
      * * => 前面是匹配项，后面是匹配成功之后执行的代码块
      * * _ 通配
      */

    //匹配字符串
    str match{
      case "男" => {
        println("性别为男")
      }
      case "女" => ("性别为女")
      case _ => println("默认值")
    }

    //匹配基本数据类型

    val age = 20
    age match{
      case 20 => println("年龄等于20")
    }
    age >=18 match {
      case true => println("成年")
      case false => println("未成年")
    }

    //匹配对象
    val user = User("张三",23)

    user match {
      case User("李四",23) =>("李四")
      case User("张三",23) => println("张三")
    }

    //匹配类型
    val user1: Any = 1

    user1 match {
      case s:String => println("是一个字符串："+ s)
      case u: User => println("是一个user:"+ u)
      case _=> println("其他类型")
    }


  }
  case class User(name:String,age:Int)
}

package com.shujia.scala

object DemoMatchMap {
  def main(args: Array[String]): Unit = {
    val map: Map[String, String] = Map("001" -> "张三","002" -> "李四")

    //通过key获取value
    println(map("001"))
    println(map.getOrElse("001","默认值"))
    println("=" * 100)

    /**
      * Option：有两个值
      * some： 有值
      * Nome： 空
      */

    val option: Option[String] = map.get("001")
    println(option)

    //通过模式匹配避免空指针异常
    //match 可以有返回值
    val value: String =option match {
      case None => "默认值" //没有取到的时候返回默认值
      case Some(v) => v  //如果取到了就返回对应的值
    }

    println(value)

    //等同于
    printf(map.getOrElse("004","默认值"))

  }
}

2.泛型

package com.shujia.scala

object DemoFanxin {
  def main(args: Array[String]): Unit = {
    /**
      * 泛型，在编译时对变量类型的限制
      * 泛型能够使编写代码更灵活
      * 1.泛型类
      *
      */

    val stu: Student4[Int] = new Student4[Int]()
    stu.print(12)

    print(3.14)
  }

  //2.泛型方法
  //T 的类型由参数类型决定
  def print[T](s:T): Unit ={
    //如果使用强转，容易出错

    //s的类型不确定，可以通过模式匹配来处理
    s match {
      case s:String => println("是一个String类型："+s)
      case i:Int => println("是一个Int类型："+i)
      case _=> println("其他类型")
    }
  }
}

//1.泛型类
class Student4[T]{
  def print(t:T): Unit ={
    println(t)
  }
}

3.java与scala之间的转换

package com.shujia.scala

import java.util

object DemoJavaToScala {
  def main(args: Array[String]): Unit = {
    //创建java中集合
    val list: util.ArrayList[String] = new util.ArrayList[String]()

    list.add("java")
    list.add("scala")
    list.add("spark")

    println(list)

    //将java集合转换成scala集合
    //导入一个java集合转换成scala集合的隐式转换
    import scala.collection.JavaConversions._
    val scalalist: List[String] = list.toList

    //导入将scala集合转换成java集合的隐式
    import scala.collection.JavaConverters._
    val java: util.List[String] = scalalist.asJava



  }
}

4.总结

package com.shujia.scala

object DemoOpt {
  def main(args: Array[String]): Unit = {
    /**
      * map:对集合中的数据进行处理，传入一行返回一行
      * flatmap：将数据展开，传入一行返回多行
      * filter：过滤
      * groupby:分组
      * sort：排序
      * foreach:遍历
      *
      */


    val list: List[Int] = List(1,2,3,4,5,6,7,8,9)

    /**
      * map
      *
      */
    val ints: List[Int] = list.map(i=>i*2)
    println(ints)

    //简写
    //如果函数的参数只用了一次，可以使用_代替
    val ints2: List[Int] = list.map(_*2)

    /**
      * flatmap
      *
      */
    val lines: List[String] = List("java,spark","scala,spark")

    val words1: List[String] = lines.flatMap(line=> line.split(","))
    println(words1)

    //简写
    val words2: List[String] = lines.flatMap(_.split(","))
    println(words2)


    /**
      * filter
      *
      */
    val list2: List[Int] = List(1,2,3,4,5,6,7,8,9)

    val list4: List[Int] = list2.filter(i=> i%2==1)

    println(list4)

    val list5: List[Int] = list2.filter(_%2 ==1)
    println(list5)

    /**
      * sort
      *
      */

    val list6: List[Int] = List(1,2,100,2,3,59,4,5,5,6,78,29,9)
    //sortBy 指定一个排序的列
    val sort1: List[Int] = list6.sortBy(i=> -i)//这是降序排序
    println(sort1)

    println("="*100)

    //sortWith：传入一个比较的规则
    val list7: List[Int] = list6.sortWith((i,j) => i<j)
    println(list7)

    /**
      * groupBy
      */
    val list8: List[Int] = List(1, 2, 100, 2, 3, 50, 4, 5, 5, 6, 7, 8, 9)
    val map: Map[Int, List[Int]] = list8.groupBy(i => i)
    println(map)


  }
}