object ScalaDemo06 {def main(args: Array[String]): Unit = {
//    val list = List(1,2,3,4,5,6)val num = 10matchVal(num)val list = List(1,2,3,45,9)list.foreach { matchVal }val ppp1 = new PPP("Angelababy",29)val ppp2 = PPP("Dilireba",26)val ppp3 = PPP("zhangxinyi",22)val ppp4 = PPP("fanbingbing",20)val ppp5 = PPP("liuyan",28)val pppList = List(ppp1,ppp2,ppp3,ppp4,ppp5)pppList.foreach { x => x match {case PPP("zhangxinyi",22) => println("value match" + x.toString())case p:PPP => println("type match" + p.toString()) case _ => println(x.toString())}}}/*** 在scala中 match 既可以进行值匹配  又可以类型匹配* 在scala中 match根据顺序从上往下去匹配，一旦匹配成功就不再继续往下匹配了*/def matchVal(num:Any) = {num match {case 10 => println(10) case 9 => println(9)case i:Int => println("Int:" + i)case _ => println("default")}}
}/*** 样例类(case classes)* 使用了case关键字的类定义就是样例类(case classes)，样例类是种特殊的类* 特点：*         1、样例类默认帮你实现了toString,equals，copy和hashCode、apply等方法*         2、样例类可以new, 也可以不用new*/
case class PPP(name:String,age:Int) {}

object ScalaDemo05 {def main(args: Array[String]): Unit = {//set集合    去重数据val set1 = Set(1, 2, 3, 4, 4)val set2 = Set(1, 2, 5)//遍历 注意：set会自动去重
    set1.foreach { println }for (s <- set1) {println(s)}//交集    .& = intersectval set3 = set1.intersect(set2)set3.foreach { println }val set4 = set1.&(set2)set4.foreach { println }println("*******")//差集  diff = &~
    set1.diff(set2).foreach { println }set1.&~(set2).foreach { println }//子集
    println(set1.subsetOf(set2))//最大值
    println(set1.max)//最小值
    println(set1.min)println("****")//1  2  3  4println(set1.mkString("\t"))//(2,"shsxt")这是一个二元组类型    用一堆小括号组织起来的元素，//Option类型有两个子类型   Some None   如果通过key能够获取到value此时返回的是Some  否则返回的是None//getOrElse如果能获取到值，那么将值返回，否则返回的是默认值  get  getOrElseval map = Map(1 -> "bjsfanbingbingxt", (2, "shsxt"), "5" -> "sasxt")println(map.get("5").getOrElse("no result"))map.foreach((x: (Any, String)) => {println(x._2)})val map1 = Map((1, "a"),(2, "b"),(3, "c"))val map2 = Map((1, "aa"),(2, "bb"),(2, 90),(4, 22),(4, "dd"))map1.++:(map2).foreach(println)println(map.contains(6))println(map.exists(x => x._2.contains("fanbingbing")))/*** 元组* 1.元组定义* 与列表不同的是元组可以包含不同类型的元素。元祖对象是通过一对小括号包裹起来组成的*/val t2 = Tuple2(1, "libingbing")val tt2 = (1, "lichen")val t3 = t2.swapprintln(t3._1 + "===" + t3._2)/*** trait    特性* 1.概念理解* Scala Trait(特征) 相当于 Java 的接口，实际上它比接口还功能强大。* 与接口不同的是，它还可以定义属性和方法的实现。* 一般情况下Scala的类可以继承多个Trait，从结果来看就是实现了多重继承。Trait(特征) 定义的方式与类类似，但它使用的关键字是 trait。* 2.举例：trait中带属性带方法实现* 注意：* 继承的多个trait中如果有同名的方法和属性，必须要在类中使用“override”重新定义。* trait中不可以传参数*/val p = new Person1p.read("Fenger")p.listen("Fenger Love you")val p1 = new Point(2, 2)val p2 = new Point(1, 3)println(p1.isEqule(p2))println(p1.isNotEqule(p2))}
}trait Read {val readType = "Read"val gender = "m"def read(name: String) {println(name + " is reading")}
}trait Listen {val listenType = "Listen"val gender = "m"def listen(name: String) {println(name + " is listenning")}
}class Person1() extends Read with Listen  {override val gender = "f"
}trait Equle {def isEqule(x: Any): Booleandef isNotEqule(x: Any) = {!isEqule(x)}
}class Point(x: Int, y: Int) extends Equle {val xx = xval yy = ydef isEqule(p: Any) = {p.isInstanceOf[Point] && p.asInstanceOf[Point].xx == xx}}

/*** Scala的隐式转换系统*     隐式转换，在编写程序的时候可以尽量少的去编写代码，*     让编译器去尝试在编译期间自动推导出这些信息来，*     这种特性可以极大的减少代码量，提高代码质量* 包含：*     隐式值*     隐式视图(隐式方法)*     隐式类*/
object ScalaDemo07 {def main(args: Array[String]): Unit = {/*** 隐式值* 隐式转换必须满足无歧义规则** 声明隐式参数的类型最好是自定义的数据类型，不要使用Int,String这些常用类型，防止碰巧冲突*/implicit val num1 = 1000//    implicit val num2 = 2000
    add/*** type mismatch; found : String("1000") required: Int* 工作原理：*         在调用sayNum的时候传入的是字符串  与sayNum定义的参数不一致*         此时他会在作用域内寻找隐式视图，发现了stringToInt(参数是string，输出是Int)*         stringToInt("1000") = 1000*         sayNum(1000)*/implicit def stringToInt(numStr: String) = Integer.parseInt(numStr)sayNum("1000")val s1 = new Student1()val s2 = new Student2()implicit def s2Tos1(s: Student2) = new Student1()s2.sayStudent("Anagelababy")/*** 隐式类* 工作原理：*         "abc"这个字符串在调用getLength方法的时候，发现没有这个方法，此时会在作用域内寻找隐式视图或者隐式类*         StringUtil隐式类,构造函数是String类型并且就一个参数，此时会将会创建StringUtil这个类的对象，将"abc"*         传入给StringUtil构造函数====StringUtil类型的对象，getLength方法*/implicit class StringUtil(str: String) {def getLength() = str.length()}println("abc".getLength)}def add(implicit num: Int) = {println(num + 1000)}/*** 隐式视图*     隐式转换为目标类型：把一种类型自动转换到另一种类型*/def sayNum(num: Int) = {println("say num:" + num)}
}class Student1 {def sayStudent(name: String) = {println(name)}
}
class Student2 {}