大数据---------spark体系之分布式计算---------scala分布式编程开发语言----------scala中的String，集合和Trait（06）

问题集锦 

---

目录

目录

1.String

2.集合

3.trait

---

正文

知识点和代码都在黑色的框子中

1.String

scala中的String类用的就是java 中的String这个类。如果有所不同，那就是scala还重写了几个方法罢了。

object Lesson_String {
  def main(args:Array[String])={
    val builder = new StringBuilder
    builder.+("a")
    builder.+("hello")
    builder.append(true)
    println(builder)
  }
}

2.集合

集合包含list array set 等等

    /**
      * Array
      */
    /*
    val arr =  Array(1,2,3,4,"hello","a",3,'c')//在array中可以不指定array中存放的类型，此时array中的类型为any，可以存放任何东西。这种用法不需要new 关键词。
    arr.foreach(println)
    for(elem<-arr){
      println(elem)
    }
    println(arr.size)
*/

/*
    val arr = new Array[String](3)//相比较上一种用法，这种情况必须用new关键词
    //赋值时下标是用小括号括起来，这个很重要。
    arr(0) = "a"
    arr(1) = "b"
    arr(2) = "c"
*/

    /**
      * List
      * 1.list的定义只有一种
      *
      */
    val list1 = List[Int](1,2,3,4)
    val list2 = List[Int](5)

    val list3 = List[String]("hello a","hello b","hello c")


    /**
      * 1. map
      * 2 使用map分割的结果是一对一的
      * *3 使用flatmap分割的结果是一对多的
      */

    //map
    /*
        val result = list3.map(s=> {//对list中字符串的分割是借助于list的map函数，map函数中可以传递一个类型为函数的参数。这个匿名函数的返回值就是split的返回值。
                                    //上一行中的s也可以理解为把list3中的数据拿出来，赋值给s。
          s.split(" ")
        })
        //输出分割后的结果
        result.foreach(
          s=>{
            println("*********")
            s.foreach(println)//foreach 是一整块for循环，而不是for循环中的一句话。
          }
        )
    */

    /*
        //flatmap
        val result1 = list3.flatMap(s=>{
          s.split(" ")
        })

        result1.foreach(println)
    */

/*
    //filter  在scala中filter会将表达式为true的结果过滤出来。将其它的忽略掉。
    val result = list3.filter(s=>{
      s=="hello a"
    })

    result.foreach(println)
*/

/*
    /**
      * set
      * 1.set是无序的，set是不含重复的元素的 。
      */
    //set的定义也不用new 只有这么一种方式
    val set1 =  Set[Int](3,2)
*/


/*
    /**
      * map
      */
    //定义
    val map = Map("r"->6,('c',3),('d',5),('c',6))//这两种方式都可以

    //取值
    val tp = map.get('c').getOrElse("xxx")
    println(tp)
    //遍历map的关键字
    val keys: Iterable[Any] = map.keys//Itetable不是迭代器类型，而是一个集合类型
    keys.foreach(println)
    //遍历map的真值
    val values = map.values
    values.foreach(println)
*/


       /**
          * tuple元组
          * 1.touple定义有两种，其中一种只需要括号，比较奇特，需要注意。
          * 2 touple最多只能有22个元素，每个元素的类型可以各不相同
          * 3 touple的遍历只能使用迭代器，迭代器名字叫productIterator
        */
        val tuple2 = new Tuple2(2,'d')
        val tuple3 = ("jjj",'c',5)

        val tupleIterator = tuple3.productIterator
        while(tupleIterator.hasNext){
          println(tupleIterator.next())
        }
        //tuple的取值
        println(tuple3._3)

3.trait

第一部分主要讲解trait的多继承问题

    /**
      * trait
      */
    trait Speak{//trait 不能传递参数
      def speak(name:String): Unit ={
        println(name+" is speaking")
      }
    }
    trait Listen{
      def listen(name:String): Unit ={
        println(name + " is listening")
      }
    }

    class Person1() extends Speak with Listen {//trait是可以多继承的，第一个继承的trait使用extends关键字，第二个继承的使用with关键字

    }
    val person2 = new Person1()
    person2.speak("xushuai")

第二部分主要讲解trait中的方法既可以实现方法体，也可以在类中实现方法体。 

package com.bjsxt.scala

trait isEqu{//trait既可以实现方法，也可以不实现方法
  def isEqule(p:Point):Boolean
  def isNotEqule(p:Point):Boolean={
    //if(this.x == p.x)
    false
  }
}

class Point(xx:Int,yy:Int) extends isEqu{
  val x = xx
  val y = yy

  def isEqule(p:Point) :Boolean={
    if(p.isInstanceOf[Point]&&this.y == p.asInstanceOf[Point].y&&this.x == p.asInstanceOf[Point].x)
      true
    else false
  }
}

object Lesson_Trait02 {
  def main(args:Array[String]): Unit ={
    val p1 = new Point(12,13)
    val p2 = new Point(12,13)
    println(p1.isEqule(p2))
  }
}