scala學習筆記

時間  2019-12-09
標籤 scala 學習 筆記 欄目 Scala 简体版
原文   原文鏈接

元組

元組是一個輕量級集合,這個集合能夠存儲任意元素java

元組是使用小括號,元素之間使用逗號分隔,元素的類型是任意的數組

若須要訪問元組中的元素 [元組名._數字] 數字是從1開始, 有多少個元素,這個1遞增多少次安全

例如: 有一個元組,元組中有三個元素多線程

　　訪問每個元素值 --> _1 _2 _3app

元組屬於輕量級的集合,數據最多隻能存儲22個框架

ps:通常元組會代替Map在Spark中使用函數

對偶元組 --> 元組中存儲的數據是成對出現的,就將出現第一個值稱爲key,第二個值的位置稱爲Valuethis

/**
  * 元組
  */
object TupleDemo {
  def main(args: Array[String]): Unit = {
    //這個就是元組的建立
    val t = ("sparkcore","sparkSQL","SparkStreaming")
    //獲取值
    val value: String = t._1

    //建立元組的同時,指定變量存儲數據(不推薦)
    val t1,(a,b,c) = ("sparkcore","sparkSQL","SparkStreaming")
    //
    val t1_1 = a
    
    //Scala中提供經過tuple元組類來建立
    //tuple1是無限大 
    //剩餘的tuple後面的數字表明瞭最多能夠存儲多少個元素
     //系統給定元組的最大值是22個,超過22就沒法存儲了,此時建議改成Array或List
    val tuple = new Tuple1(1.3,14,"你好")
    val tuple2 = new Tuple2(1.3,14)
  }

　　

元組的遍歷

val tuple = new Tuple1(1.3,14,"你好")
    val tuple2 = new Tuple2(1.3,14)

     //遍歷方式1(迭代器遍歷)
      for(ele <- tuple.productIterator){
        println(ele)
      }
    //遍歷集合 --> foreach 這個方法就是遍歷集合使用,沒有返回值
    //foreach方法是獲取集合每個元素並處理, 返回值是一個泛型,因此最終輸出什麼數據類型由需求決定
    /*
    方法:
      def 方法名(參數列表):返回值類型 = { 方法體 }
    函數:
      val 函數名 = (參數列表) => {函數體}
     */
    //先定義一個函數
     val pt = (x:Any) =>{println(x)}
    tuple.productIterator.foreach(pt)

    //匿名函數
    tuple.productIterator.foreach((x:Any) =>{println(x)})
    //簡化
    tuple.productIterator.foreach(x =>println(x))
    //只須要一個能夠獲取數據的變量--> 此時可使用 下劃線代替
    tuple.productIterator.foreach(println(_))
    //由於是打印數據,此時參數是默認(就是遍歷集合獲取來的,此時Scala容許再次省略下劃線)
    tuple.productIterator.foreach(println)

　　

拉鍊操做

做用:將兩個元組中的數據造成對偶元組spa

package Scala_03

/**
  * 拉鍊操做
  */
object TupleDemo2 {
  def main(args: Array[String]): Unit = {
      //zip就是元組的拉鍊操做,將兩個元組中數據進行合併,造成對偶元組
      val name = Array("tom","jerry","kitty")
      val scores = Array(2,3,4)
    //當前數組中存儲的是一個一個的元組對象
    //誰調用方法就是就是key,誰作參數傳遞 誰就是 value
    val tuples: Array[(String, Int)] = name.zip(scores)
    println(tuples.toBuffer)

    //兩個存儲數據的集合 中的數據不一致
    val name_1 = Array("tom","jerry","kitty")
    val scores_2 = Array(2,3)
    //ps:若是兩個集合數據長度不一致,此時拉鍊操做誰以最小長度的集合爲基準 進行對偶元組合並,多餘的部分會刪除
    val tuples_2: Array[(String, Int)] = name_1.zip(scores_2)
    println(tuples_2.toBuffer)

    //zipAll 和zip是相似的,可是若齊總某一個集合集合中的元素缺乏,將使用默認元素填充
    val xs = List(1,2,3)
    val zx = List("一","二","三","四")
    val tuples_3 = xs.zipAll(zx,0,'_')
    println(tuples_3)

    //zipwithIndex 將集合中元素和因此進行結合
    val list = List(1,2,3)
    val tuples_4 = list.zipWithIndex
    println(tuples_4.toBuffer)
    //若須要從指定位置開始組合
    val tuples_5 = list.zip(Stream from 1)
    

  }
}

　　

列表List

Scala中的集合是分爲可變和不可變線程

Scala中默認使用是不可變集合包 scala.collection.immutable

package Scala_03

/**
  * list集合
  */
object ListDemo {
  def main(args: Array[String]): Unit = {
    val empty = List()  //空集合
    val names = List("xiaobai","xiaohong","xiaohuang") //有值
    val moreList = List(List(1,2,3),List(2,3,4))// 集合中存儲的數據是另一個集合對象
    //運算符
    //列表中有一個默認空值 nil 它能夠和 :: 中綴符 一塊兒使用 構建集合對象
    // :: 和 nil一塊兒使用 它 是右結合
    val str:List[String] = ("小明" :: ("小紅" :: ("小黃" :: Nil)))
    println(str)
    val s = List("姓名")
    //將其餘集合中數據添加到當前集合彙總
     val strs :List[String] = "小明" :: "小紅" :: "小黃" :: s
     println(strs)
   //使用nil以後會將當前集合先看作是一個總體 nil就至關於建立了集合,因此當前全部數據 都會當前集合中元素進行存儲
     // s 就會當作一個List集合對象存儲到當前集合中
    val ss = "小明" :: "小紅" :: "小黃" :: s :: Nil
    println(ss)
   
  }
}

　　

列表添加數據

package Scala_03

object ListDemo2 {
  def main(args: Array[String]): Unit = {
      val  list = List(1,2,3)
     //全部不可變list操做都會返回一個全新的List
     val list2 =  0 :: list  //     添加數據
    val list3 = 0 +: list   //都是向集合的開頭添加數據
    val list4  = list :+ 4 //向集合的末尾提N家數據
    val list5 = list ++ list4 //將兩個集合合併
    //將某一個集合添加到當前集合的前面
   val list6 = list4 ++: list
    val list6_1  = list4 ::: list //此操做和上面的操做是同樣的
    
  }
}

　　

列表的經常使用操做方法

package Scala_03

object ListDemo3 {
  def main(args: Array[String]): Unit = {
    //遍歷集合的方法:
    /*
     1.map遍歷集合獲取集合中每個元素,並將元素進行處理(自定函數函數),返回一個全新的集合
     2.filter遍歷集合獲取集合每個元素,並將元素進行處理(這個自定義函數返回值必須是Boolean)
     而後只有獲得true,纔會存儲到新的集合中
     這兩個方法一樣適用於List
     */
    //3.foreach 這個方法主要做用即便遍歷集合並處理集合中數據(自定義函數),這個方法沒有返回值
    val list = List(1,2,3)
    val list_1: List[Int] = list.map(_*2)
    val list_2: List[Int] = list.filter(_>1)
    list.foreach((x:Int)=>println(x))
    list.foreach(x => println(x))
    list.foreach(println(_))
    list.foreach(println)
    /*
    map和foreach的區別
    1.map方法存在返回值,處理完數據以後會返回一個新的集合可是foreache是沒有返回值的,處理完數據以後時沒有返回結果的
    2.由於map具備返回值,因此map多用於進行集合中數據處理,而foreach沒有返回值,因此多用於打印集合集合中數據
     */
    //ps:s雖然foreach不具有返回值,可是foreach內部處理函數和Map實際上是同樣的,因此foreach也能夠對集合中數據操做,操做完成以後多用於輸出
    //例如 map將集合集合中的元素擴大二倍,foreach也可作到,可是不能返回值出新的集合
      list.foreach(x=>println(x*2))
     // list.max  最大值  list.min 最小值

    //head 返回列表第一個元素
      val head: Int = list.head
    //tail 返回除第一個元素以外的其餘元素
      val tail: List[Int] = list.tail
    //concat 將兩個集合拼接 至關因而 ++
      val list1 = List(4,5,6)
    val newList: List[Int] = List.concat(list,list1)
    //反轉
     val reverse: List[Int] = list.reverse
    //長度
    //list.length    list.size
    //take -> TopN   提取列表前N個數據 --> N就是具體的數值
      val topN: List[Int] = list take 1
    //拉鍊 zip  zipAll  zipwithIndex均可以使用
    //list.sorted  list.sortwith 均可以使用排序
     //丟棄列表前N數據 --> N是具體的值

      val ints: List[Int] = list drop 1
  }
}

　　

可變list

package Scala_03
/*
可變ListBuffer
 */
object ListBufferDemo {
  def main(args: Array[String]): Unit = {
      import scala.collection.mutable.ListBuffer
      val list1 = ListBuffer[Int](1,2,3)
      val list2 = new  ListBuffer[Int]
      list2 += 4  //追加
      list2.append(1)
      list2 ++= list1 //添加集合
    
  }
}

對列表進行拆分
val list = List(1,2,3)
val List(a,b,c) = list
此時 a b 和c 就會獲取 1,2,3的值

　　

Set

建議使用HashSet

package Scala_03

import scala.collection.immutable.HashSet
import scala.collection.mutable

/*
   不可變和可變 HashSet是排重
   Hash表 --> 數組+鏈表
 */
object HashSetDemo {
  def main(args: Array[String]): Unit = {
         val set = new HashSet[Int]()
         val set1: HashSet[Int] = set+1 //添加
         val set2 = set1 ++ Set(1,2,3)//合併集合
        println(set2)
      //除了HashSet以外 可使用使用Set
       val s = Set(1,2,3)
      
        import  scala.collection.mutable._
        val mutableSet = Set(1,2,3)//可變Set
        val set3 = new mutable.HashSet[Int]()
         set3 += 2
         set3.add(4)
    //存在則刪除,不存在 不會報錯不生效
         set3  -= 2
         set3.remove(2)
  }
}

　　

兩個Set集合操做

package Scala_03

/**
  * 兩個Set集合操做
  */
object SetDemo2 {
  def main(args: Array[String]): Unit = {
      //合併Set集合
      val set1 = Set(5,6,9,20,30,45)
      val set2 = Set(50,60,9,20,35,55)
       val set  = set1 ++ set2
    //交集
      println(set1.&(set2))
    println(set1.intersect(set2))
    //並集
     println(set1.union(set2))
    //差集
     println(set1.diff(set2))
    //遍歷Set
      val iterator = set1.iterator
     while(iterator.hasNext){
       println(iterator.next)
     }
    
  }
}

　　

總結:

Scala中集合:分爲可變和不可變

List Set Array Map -->可變和不可變,Array是定長和變長

元組輕量級存儲數據的一個集合,最多隻能存儲22個元素多用因而對偶元組代替Map

在Spark中使用級別: 元組->Array-->List--->Map---->Set

整個集合記住基本操做 添加數據和建立,集合全部的經常使用方法必須記住

集合經常使用方法

ps:方法主要是以Array和List爲主,其他Map和Set可使用個別方法
遍歷集合:
map 遍歷操做數據並返回
filter遍歷操做數據並返回 知足Boolean表達式
foreach  遍歷操做數據可是沒有返回多用於打印

package Scala_03

/**
  * 經常使用方法
  */
object CollectionMethodDemo {
  def main(args: Array[String]): Unit = {
        val list = List(List(1,2,3),List(4,5,6))
    //要求:  將集合進行處理 並獲得 一個 新的集合 List(1,2,3,4,5,6)
      //壓平集合(能夠將集合中存儲的集合進行扁平化處理)
     //將集合存儲的集合對象進行扁平化處理(將存儲在集合對象中集合數據獲取出來造成一個新的集合)
     val flatten: List[Int] = list.flatten
      println(flatten)

      val line = List("hello tom hello jerry","hello xiaobai hello")
    //需求將當前集合中的數據進行處理  -- >  List("hello","tom","hello".....)
       val stringses: List[Array[String]] = line.map(_.split(" "))
       stringses.foreach(x=>println(x.toBuffer))
        val list_1 = stringses.flatten
       println(list_1)

     //Scala中爲了應對數據中存在集合套用集合的狀況,推出 faltMap --> 就是flatten + Map  遍歷的同時並壓平
     val line_1 = List("hello tom hello jerry","hello xiaobai hello")
    val strings: List[String] = line_1.flatMap(_.split(" "))
    /*
    flatMap和Map的區別
    均可以對數據繼續進行遍歷處理,.map只是對數據處理並不具有對數據的扁平化處理,flatmap是Flatten+Map結合體,便可以遍歷數據也能夠對數據進行
      扁平化處理,flatMap是Spark中比較經常使用獲取數據後的處理方法,其次是Map,可是flatMap是有侷限性,在於它會壓平數據,不是全部的狀況都須要壓平.
     */

    //forall 對整個集合中元素進行條件過濾.只有當全部元素都知足的時候,纔會返回true 不然就是false
       val  list_2 = List(1,2,3,4,5)
    val bool: Boolean = list_2.forall( _ < 3)

    //partition  分區 主要是對集合集合彙總數據進行分區(分組)
    //scala中體現就是出現不一樣集合, 可是在SparkCore中是存在不一樣分區中[Sparkcore中體現]
    val  list_3 = List(1,2,3,4,5,6)
    //這boolean類型表達式決定如何分數據
      val tuple: (List[Int], List[Int]) = list_3.partition(_%2 == 0)

    //fold 和  reduce
    //fold是一個聚合函數(求和) 須要兩個參數  第一個是默認值  第二個參數是計算邏輯
    //計算流程: 首先x會先獲取0這個初始值,而後y會獲取集合第一個元素而後相加
    //          以後的每一次計算 x獲取的都是上一次計算的結果 即 x  = x+y
    //           y值依舊獲取集合中剩餘的元素進行計算 ,最終中止是是y不能再獲取到集合元素時中止
    val  list_4 = List(1,2,3,4,5)
      val sum = list_4.fold(0)((x,y) => x+y)
    
    //reduce  
    //計算流程 首先x和y會獲取集合中第一個或第二個元素的值並進行計算 --> 1+2 = 3
     //       以後的每一次計算x獲取的是上一次計算的結果即 x = x+y  而y繼續獲取剩餘的集合中的元素參與運算 直到集合中沒有元素中止
    list_4.reduce((x,y)=>x+y)


  }
}

求和 sum 
排序 sorted , sortwith
最大值 max  和 最小值 min

　　

Scala版本的WordCount

 

package Scala_03
/*
Scala版本  模仿作的
 */
object WordCount {
  def main(args: Array[String]): Unit = {
    // 讀取文件數據存儲在集合中
    val line = List("hello tom hello jerry","hello xiaobai hello","hello tom")
    //將集合中的數據進行處理,,獲取集合中每一條字符串,將字符串進行拆分獲得單詞
     val words: List[String] = line.flatMap(_.split(" "))
    //須要將單詞以KV的形式記性拼接  -->  (單詞,1) --> 明確當前存儲類型就是kv鍵值對
    // Scala中提供兩種方式 Map 和 元組 --> 推薦使用元組,緣由在於元組擦操做數據更加方便,不會像Map同樣須要調用get方法獲取數據
    val tuples: List[(String, Int)] = words.map((_,1))
    //單詞和次數已經成爲了元組,須要對次數進行累加,問題是不知道哪些單詞是一組
    //  將相同的單詞進行分組
    //            key 單詞   value 原有單詞所存在的元組
    val grouped: Map[String, List[(String, Int)]] = tuples.groupBy(_._1)
      //此時已經根據單詞進行了分組 相同的單詞會匯聚成List集合,經過reduce來進行計算能夠相對來講比較麻煩
      val sumed:Map[String,Int] = grouped.mapValues(_.size)
    //Top1 ,數據已經存在Map集合中,此時進行排序
       val list: List[(String, Int)] = sumed.toList  //Map轉換爲List時會將kv鍵值對以元組的形式存
    //這個排序是根據傳入的指定值來進行排序的,默認是升序,沒法直接降序,Spark中有一個和這個方法同樣的sortBy,是能夠自由升序降序
      val sortedList = list.sortBy(_._2)
       val reverseList = sortedList.reverse
        val top1 = reverseList take 1
    println(top1)

    //正常版本
    val top2 = line.flatMap(_.split(" ")).map((_,1)).groupBy(_._1).mapValues(_.size).toList.sortBy(_._2).reverse.take(1)
 

  }
}

　　

並行化par

緣由:Spark是一個並行計算框架,基於內存,因此會開啓多個線程執行程序
Scala中可使用par進行多線程模擬
package Scala_03

/**
  * 並行化
  */
object ParDemo {
  def main(args: Array[String]): Unit = {
      /*
      Spark在編寫程序的時候,能夠提交集羣運行,也能夠在本地執行
      能夠在編寫Spark程序的時候 進行本地運行配置setMaster 運行模式設置
      須要開啓本地運行--> 咱們三種方式
      local   --> 單線程
      local[值]  --> 更值來開啓對應的線程數,用來模擬spark的平行計算
      local[*]  --> * 主要表明當前電腦空閒多少線程就使用多少線程來進行模擬計算
       */
      //用par模擬並行化計算
      //1.求和 -->聚合函數  --> sum , fold  ,reduce
      //1.1 sum進行計算
      println("--------------------------------sum計算------------------------------------")
      //ps:sum只能用來求和沒法計算其餘方式
      val arr = List(1,2,3,4,5,6,7,8,9,10) //55
      //單線程計算
       val sumed = arr.sum
       println("單線程sum:"+sumed)  // 1+2+3+4...
      //開啓平行化處理計算
       val sumed2 = arr.par.sum
      println("多線程sum:"+sumed)  //(1+2)+(3+4+5+6)+(7+8+9+10)
      //總結:不管是在單線程仍是多線程計算求和計算結果都是沒有問題
      println("--------------------------------sum計算------------------------------------")

      //reduce 求和
    println("--------------------------------reduce計算------------------------------------")
    //ps:sum只能用來求和沒法計算其餘方式
    val arr_1= List(1,2,3,4,5,6,7,8,9,10) //55
    //單線程計算
    val sumed3 = arr_1.reduce(_+_)
    println("單線程reduce:"+sumed3)  // 1+2+3+4...
    //開啓平行化處理計算
    val sumed3_1 = arr_1.par.reduce(_+_)
    println("多線程reduce:"+sumed3_1)  //(1+2)+(3+4+5+6)+(7+8+9+10)
    //總結:不管是在單線程仍是多線程計算求和計算結果都是沒有問題

    //reduce是能夠寫本身的計算邏輯,既然可使用+  同理也能夠計算 -
    //單線程計算
    val sub = arr_1.reduce(_-_)   // 1-2-3-4...
    println("單線程reduce:"+sub)
    //開啓平行化處理計算  此時不知道有多少個線程在線程在執行(1-2)  -(3-4-5)  -  (9-10)
    val sub_1 = arr_1.par.reduce(_-_)
    println("多線程reduce:"+sub_1)
    //在計算求差值計算時候reduce是沒法保證在多線程下計算記過準確
    // reduceleft  和 reduceright  --> 不管是單線程仍是多線程 ->都是按照一個方向計算計算的
    //可使用reduceleft來修正計算計算記過 --> 必須是從左向右計算
    val sub_2 = arr_1.par.reduceLeft(_-_)
    println("多線程reduce:"+sub_2)
    //在Spark並行計算中若是須要使用計算求差值這樣的計算,建議使用 reduceLeft   --> reduceRight計算邏輯和left是同樣的(從右向左)
    println("--------------------------------reduce計算------------------------------------")

    //fold 求和
    println("--------------------------------fold計算------------------------------------")
    //ps:sum只能用來求和沒法計算其餘方式
    val arr_2= List(1,2,3,4,5,6,7,8,9,10) //55
    //單線程計算
    val sumed4 = arr_2.fold(10)(_+_)
    println("單線程fold:"+sumed4)  // 1+2+3+4...
    //開啓平行化處理計算
    val sumed4_1 = arr_2.par.fold(10)(_+_)  //fold一旦開啓並行化,就會進行屢次的計算--> 當前整個初始值只要進行進行一次線程計算
    //就會盡心一次10的相加 --> 例如: 10+1+2 --> 12   10+3+4
    println("多線程fold:"+sumed4_1)
     //總結在平行化的前提下,fold 不建議進行 求和計算,由於會屢次計算初始值,若是須要當前初始值只計算一次
    //foldLeft 和 foldRight  --> 強制要求計算方式是從左向後  和 從右向左
    val sum5 = arr_2.par.foldLeft(10)(_+_)

     
    //聚合函數    aggregate 和 fold相似 可是 計數邏輯多
     //  aggregate(初始值)(局部聚合,全局聚合)  --> aggregateByKey(SparkCore中算子)

    println("--------------------------------fold計算------------------------------------")
  }
}

　　

面向對象

Scala語言和Java語言,世間萬物皆對象,Scala也是面向對象的語言,Scala的面向對象和Java的面向對象本質概念同樣,語法時區別

Java的面向對象 Scala中面向對象
建立一個Java類只能使用class 建立一個類可使用class和object
Java中有豐富權限修飾符,每一個權限修飾符均可以很好限制對類和勒種屬性,方法的訪問方式 Scala中權限修飾符本質只有兩個一個就是public和另一個private,默認使用修飾符是public
Java中類的構造方法須要寫在類的內部,以方法的實行出現,而且主要是爲了對屬性進行賦值 Scala中構造方法有兩種,一種是主構造器(一個類中只能有一個),另一個是輔助構造器(一個類中能夠有多個)
Java中是有抽象類,抽象類中能夠定義抽象方法可是必須使用abstract Scala中也有抽象類,Scala中也存在抽象方可是不須要使用abstract,Scala容許抽象屬性
Java中類比較單一就是class修飾普通類,只不過功能上會進行區分(描述類和執行類) Scala中提供一個概念,伴生類和伴生對象(在同一個文件中類名相同,分別使用class和object修飾)
Java中接口分爲兩種,一種是Java8以前的這個接口只能建立屬性和抽象方法,另一種中是Java8以後這個接口便可以定義屬性和抽象方法也能夠第定義實現方法(default修飾 和 static修飾) Scala中特質Trait本質上和Java中接口是沒有區別(應對的是Java8之後接口),容許定義屬性和抽象方法而且能夠提供實現的方法
 
   

Scala中定義類和屬性

ps:在scala中描述一個事物須要使用class修飾的,在Scala中須要執行代碼即執行類須要使用object來修飾

Scala中 object表明的是類的修飾,而Java中Object表明的是超級父類,Scala中的超級父類是Any

package Scala_03
//Scala類中屬性
/*
 在Scala中類並不須要使用public修飾,由於默認都是共有
 在Scala中class修飾的類都是用來描述事物的,在沒有指定構造發方法以前,默認是存在一個無參構造方法的
 */
class Student {
    //類中定義屬性
    /*
      由於Scala中對變量的修飾基本上即便var 和 val,這樣兩種修飾一樣適用於屬性
      定義屬性時使用var修飾,那麼就至關於屬性自帶getter和setter
      定義屬性時使用val修飾,那麼就至關於屬性自帶getter
       Scala類聲明屬性,若是使用自動推斷,必須顯示的進行賦值
                         不想使用自動推斷,此時必須明確表示該數據類型是什麼
     */
     var name  = "tom"
     var age:Int = _  //當前屬性並不須要初始值,此時可使用 _ 做爲佔位符代替初始值
     //val修飾屬性不可使用_ 佔位由於是隻讀屬性 只會被賦值一次,一但使用下劃線 就沒法在賦新值
     //  val gender:String= _
     //沒有明確數據類型,此時不容許使用下劃線
     //var  address = _
     // 可使用 私有修飾符 (伴生類能夠訪問這個私有屬性)
     private  var height :Int  = 155
     
     //對屬性更加嚴格的權限控制 [this]表明只能當前類訪問 伴生類也不能夠
    private[this] val cardID = "123456"
  
     //建立對象
     val student = new  Student()
      
  // val student = Student//這樣的建立多用因而伴生類 --> 觸發 apply方法  Student必須是一個Object類
  
}

　　

自定義getter和setter方法

package Scala_03
/*
自定義getter和setter
 */
class Ponit {
      /*
         爲了保證數據安全,面向對象中封裝性
         會將屬性進行私有化設置 作私有化屬性時建議的命名規則 要求以 _ 爲前綴, 定義屬性的名字 例如 _屬性名
         getter方法  def 方法名 =  當前屬性   --> 方法名是當前屬性的名字
         setter方法  def 方法名(參數列表):Unit = { 對屬性賦值}  --> 方法名必須是  屬性名_
       */
     private var  _x = 0
    //獲取這個屬性  getter
    def  x = _x
   //賦值  setter
    def  x_(x:Int):Unit = {
        _x = x
    }
     def  showInfos()={
         val p = new  Ponit()
         //獲取屬性
         println(p.x)
         p.x_(10)
     }

}

　　

Bean屬性

爲了方便從Java程序猿轉變爲Scala程序猿,方法理解和使用和Java中getter和Setter徹底同樣

ps:這種方式不能私有化

package Scala_03

import  scala.beans.BeanProperty
class Person {
   //在建立屬性時候提供getter和setter方法,使用是一個註解
    @BeanProperty var name:String = _
}
object Person{
  def main(args: Array[String]): Unit = {
      val p = new Person()
     p.getName
      p.setName("1")
  }
}

　　

Scala中集合和Java中集合互相轉換

package Scala_03

import java.util

import scala.collection.mutable

/**
  * 集合互相轉換
  */
object ScalaToJava {
  def main(args: Array[String]): Unit = {
    import  scala.collection.JavaConverters._
    //將當前集合轉換爲Java中的List
          val javaC: util.List[Int] = List(1,2,3,4).asJava
    //Java中集合轉換爲Scala中集合
        val scalaC: mutable.Buffer[Int] = javaC.asScala
      //萬能方法 toXXXX -> XX就是你要轉換的集合
       scalaC.toList
    
  }
}
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程